blob: 67e47e7b37a3e858982fd20be7407b9f62b501ca [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>
20#include <variant>
21
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080022#include <compositionengine/Display.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070023#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080024#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070025#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070026#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080027#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070028#include <compositionengine/mock/DisplaySurface.h>
chaviw0ef7caa2021-01-05 11:04:50 -080029#include <gui/ScreenCaptureResults.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070030
Lloyd Pique90c115d2018-09-18 21:39:42 -070031#include "BufferQueueLayer.h"
32#include "BufferStateLayer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070033#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080034#include "DisplayDevice.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080035#include "EffectLayer.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070036#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080037#include "FrameTracer/FrameTracer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070038#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070039#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070040#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070041#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070042#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080043#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070044#include "SurfaceFlingerDefaultFactory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070045#include "SurfaceInterceptor.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070046#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010047#include "mock/DisplayHardware/MockComposer.h"
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
Pablo Gamitoc351d6f2020-09-17 15:34:26 +000085 sp<SurfaceInterceptor> createSurfaceInterceptor() override {
86 return new android::impl::SurfaceInterceptor();
Lloyd Pique90c115d2018-09-18 21:39:42 -070087 }
88
89 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070090 return new StartPropertySetThread(timestampPropertyValue);
91 }
92
Lloyd Pique9370a482019-10-03 17:58:30 -070093 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
94 return new DisplayDevice(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070095 }
96
97 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
98 uint32_t layerCount, uint64_t usage,
99 std::string requestorName) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700100 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
101 }
102
103 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
104 sp<IGraphicBufferConsumer>* outConsumer,
105 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700106 if (!mCreateBufferQueue) {
107 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
108 return;
109 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700110 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
111 }
112
Lloyd Piquee300b312019-10-03 13:03:45 -0700113 sp<IGraphicBufferProducer> createMonitoredProducer(const sp<IGraphicBufferProducer>& producer,
114 const sp<SurfaceFlinger>& flinger,
115 const wp<Layer>& layer) override {
116 return new MonitoredProducer(producer, flinger, layer);
117 }
118
119 sp<BufferLayerConsumer> createBufferLayerConsumer(const sp<IGraphicBufferConsumer>& consumer,
120 renderengine::RenderEngine& renderEngine,
121 uint32_t textureName, Layer* layer) override {
122 return new BufferLayerConsumer(consumer, renderEngine, textureName, layer);
123 }
124
Lloyd Pique90c115d2018-09-18 21:39:42 -0700125 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
126 const sp<IGraphicBufferProducer>& producer) override {
127 if (!mCreateNativeWindowSurface) return nullptr;
128 return mCreateNativeWindowSurface(producer);
129 }
130
Lloyd Pique70d91362018-10-18 16:02:55 -0700131 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
132 return compositionengine::impl::createCompositionEngine();
133 }
134
Lloyd Pique90c115d2018-09-18 21:39:42 -0700135 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700136 return nullptr;
137 }
138
139 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700140 return nullptr;
141 }
142
Vishnu Nairfa247b12020-02-11 08:58:26 -0800143 sp<EffectLayer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700144
145 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700146 return nullptr;
147 }
148
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800149 std::unique_ptr<FrameTracer> createFrameTracer() override {
150 return std::make_unique<mock::FrameTracer>();
151 }
152
Adithya Srinivasan01189672020-10-20 14:23:05 -0700153 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800154 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
155 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700156 }
157
Lloyd Pique90c115d2018-09-18 21:39:42 -0700158 using CreateBufferQueueFunction =
159 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
160 sp<IGraphicBufferConsumer>* /* outConsumer */,
161 bool /* consumerIsSurfaceFlinger */)>;
162 CreateBufferQueueFunction mCreateBufferQueue;
163
164 using CreateNativeWindowSurfaceFunction =
165 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
166 const sp<IGraphicBufferProducer>&)>;
167 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700168
169 using CreateCompositionEngineFunction =
170 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
171 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700172};
173
174} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800175
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800176class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800177public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700178 using HotplugEvent = SurfaceFlinger::HotplugEvent;
179
Ady Abrahame9ebce02022-02-03 12:05:06 -0800180 TestableSurfaceFlinger()
181 : mFlinger(sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization)) {
182 mFlinger->mAnimationTransactionTimeout = ms2ns(10);
183 }
184
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700185 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700186 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700187
Lloyd Piquef58625d2017-12-19 13:22:33 -0800188 // Extend this as needed for accessing SurfaceFlinger private (and public)
189 // functions.
190
Peiyong Lin833074a2018-08-28 11:53:54 -0700191 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700192 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800193 }
194
195 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700196 mFlinger->mCompositionEngine->setHwComposer(
197 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800198 }
199
Alec Mourie4034bb2019-11-19 12:45:54 -0800200 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
201 mFlinger->mCompositionEngine->setTimeStats(timeStats);
202 }
203
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800204 enum class SchedulerCallbackImpl { kNoOp, kMock };
205
206 static constexpr struct OneDisplayMode {
207 } kOneDisplayMode;
208
209 static constexpr struct TwoDisplayModes {
210 } kTwoDisplayModes;
211
212 using RefreshRateConfigsPtr = std::shared_ptr<scheduler::RefreshRateConfigs>;
213
214 using DisplayModesVariant =
215 std::variant<OneDisplayMode, TwoDisplayModes, RefreshRateConfigsPtr>;
216
Ady Abraham8cb21882020-08-26 18:22:05 -0700217 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
218 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700219 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800220 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800221 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
222 DisplayModesVariant modesVariant = kOneDisplayMode) {
223 RefreshRateConfigsPtr configs;
224 if (std::holds_alternative<RefreshRateConfigsPtr>(modesVariant)) {
225 configs = std::move(std::get<RefreshRateConfigsPtr>(modesVariant));
226 } else {
227 DisplayModes modes = {DisplayMode::Builder(0)
228 .setId(DisplayModeId(0))
229 .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
230 .setVsyncPeriod(16'666'667)
231 .setGroup(0)
232 .build()};
Ady Abrahamabc27602020-04-08 17:20:29 -0700233
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800234 if (std::holds_alternative<TwoDisplayModes>(modesVariant)) {
235 modes.emplace_back(DisplayMode::Builder(1)
236 .setId(DisplayModeId(1))
237 .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
238 .setVsyncPeriod(11'111'111)
239 .setGroup(0)
240 .build());
241 }
242
243 configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, DisplayModeId(0));
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700244 }
245
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800246 const auto currFps = configs->getCurrentRefreshRate().getFps();
Ady Abraham3efa3942021-06-24 19:01:25 -0700247 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(currFps);
Ady Abraham23ea9da2021-07-14 16:32:56 -0700248 mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
249 mFlinger->mVsyncConfiguration->getCurrentConfigs());
Marin Shalamanov68a94092020-11-24 17:48:00 +0100250 mFlinger->mRefreshRateStats =
251 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, currFps,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800252 hal::PowerMode::OFF);
253
254 using Callback = scheduler::ISchedulerCallback;
255 Callback& callback = callbackImpl == SchedulerCallbackImpl::kNoOp
256 ? static_cast<Callback&>(mNoOpSchedulerCallback)
257 : static_cast<Callback&>(mSchedulerCallback);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700258
Dominik Laskowski068173d2021-08-11 17:22:59 -0700259 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800260 std::move(vsyncTracker), std::move(configs),
261 callback);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700262
Dominik Laskowski98041832019-08-01 18:35:59 -0700263 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
264 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700265 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700266 }
267
Dominik Laskowski068173d2021-08-11 17:22:59 -0700268 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700269
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800270 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
271 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800272
Ady Abraham2739e832022-02-14 17:42:00 -0800273 auto& mutableVsyncModulator() { return mFlinger->mVsyncModulator; }
274
Lloyd Pique90c115d2018-09-18 21:39:42 -0700275 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800276 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700277 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800278 }
279
Lloyd Pique90c115d2018-09-18 21:39:42 -0700280 using CreateNativeWindowSurfaceFunction =
281 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800282 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700283 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800284 }
285
Daniel Solomon42d04562019-01-20 21:03:19 -0800286 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
287 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
288 }
289
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700290 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700291
Valerie Haud251afb2019-03-29 14:19:02 -0700292 auto& mutableStateLock() { return mFlinger->mStateLock; }
293
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700294 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
295 const sp<const DisplayDevice>& display) {
296 return layer->findOutputLayerForDisplay(display.get());
297 }
298
299 static void setLayerSidebandStream(const sp<Layer>& layer,
300 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800301 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800302 layer->mSidebandStream = sidebandStream;
Lloyd Piquede196652020-01-22 17:29:58 -0800303 layer->editCompositionState()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700304 }
305
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500306 void setLayerCompositionType(const sp<Layer>& layer,
307 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700308 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800309 LOG_ALWAYS_FATAL_IF(!outputLayer);
310 auto& state = outputLayer->editState();
311 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700312 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700313 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800314
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700315 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700316 layer->mPotentialCursor = potentialCursor;
317 }
318
Garfield Tande619fa2020-10-02 17:13:53 -0700319 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000320 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700321 }
322
Lloyd Piquef58625d2017-12-19 13:22:33 -0800323 /* ------------------------------------------------------------------------
324 * Forwarding for functions being tested
325 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800326
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700327 nsecs_t commit() {
328 constexpr int64_t kVsyncId = 123;
329 const nsecs_t now = systemTime();
330 const nsecs_t expectedVsyncTime = now + 10'000'000;
331 mFlinger->commit(now, kVsyncId, expectedVsyncTime);
332 return now;
333 }
334
335 void commitAndComposite() { mFlinger->composite(commit()); }
336
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 Laskowski9e168db2021-05-27 16:05:12 -0700362 auto commitTransactionsLocked(uint32_t transactionFlags) {
363 Mutex::Autolock lock(mFlinger->mStateLock);
364 return mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800365 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800366
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700367 void onComposerHalHotplug(hal::HWDisplayId hwcDisplayId, hal::Connection connection) {
368 mFlinger->onComposerHalHotplug(hwcDisplayId, connection);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800369 }
370
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800371 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700372 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800373 return mFlinger->setDisplayStateLocked(s);
374 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800375
Dominik Laskowski83b88212018-12-11 13:34:06 -0800376 // Allow reading display state without locking, as if called on the SF main thread.
377 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
378 return mFlinger->onInitializeDisplays();
379 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800380
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100381 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
382
Alec Mouricdf16792021-12-10 13:16:06 -0800383 auto setDisplayBrightness(const sp<IBinder>& display,
384 const gui::DisplayBrightness& brightness) {
385 return mFlinger->setDisplayBrightness(display, brightness);
386 }
387
Dominik Laskowski83b88212018-12-11 13:34:06 -0800388 // Allow reading display state without locking, as if called on the SF main thread.
389 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700390 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800391 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800392 }
393
chaviw426b5c02020-07-27 11:20:15 -0700394 auto renderScreenImplLocked(const RenderArea& renderArea,
395 SurfaceFlinger::TraverseLayersFunction traverseLayers,
Alec Mouria90a5702021-04-16 16:36:21 +0000396 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
397 bool forSystem, bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700398 ScreenCaptureResults captureResults;
chaviwc6ad8af2020-08-03 11:33:30 -0700399 return mFlinger->renderScreenImplLocked(renderArea, traverseLayers, buffer, forSystem,
chaviw17ac24b2021-01-28 18:50:05 -0800400 regionSampling, false /* grayscale */,
401 captureResults);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700402 }
403
chaviw4b9d5e12020-08-04 18:30:35 -0700404 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200405 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700406 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700407 }
408
Daniel Solomon42d04562019-01-20 21:03:19 -0800409 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
410 ui::DisplayPrimaries &primaries) {
411 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
412 }
413
Arthur Hung58144272021-01-16 03:43:53 +0000414 auto& getTransactionQueue() { return mFlinger->mTransactionQueue; }
415 auto& getPendingTransactionQueue() { return mFlinger->mPendingTransactionQueues; }
ramindani4d48f902021-09-20 21:07:45 +0000416 auto& getTransactionCommittedSignals() { return mFlinger->mTransactionCommittedSignals; }
Valerie Haud251afb2019-03-29 14:19:02 -0700417
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000418 auto setTransactionState(
419 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
420 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
421 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
422 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
423 std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
424 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
425 inputWindowCommands, desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800426 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
427 listenerCallbacks, transactionId);
Valerie Haud251afb2019-03-29 14:19:02 -0700428 }
429
Vishnu Nair7891e962021-11-11 12:07:21 -0800430 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(0); };
Valerie Haud251afb2019-03-29 14:19:02 -0700431
Eduardo Rochaac867192020-09-14 20:12:17 +0000432 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
433 return mFlinger->onTransact(code, data, reply, flags);
434 }
435
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800436 auto getGPUContextPriority() { return mFlinger->getGPUContextPriority(); }
437
Ady Abraham899dcdb2021-06-15 16:56:21 -0700438 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
439 std::chrono::nanoseconds presentLatency) const {
440 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800441 }
442
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100443 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode,
444 bool allowGroupSwitching, float primaryRefreshRateMin,
445 float primaryRefreshRateMax, float appRequestRefreshRateMin,
446 float appRequestRefreshRateMax) {
447 return mFlinger->setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching,
448 primaryRefreshRateMin, primaryRefreshRateMax,
449 appRequestRefreshRateMin,
450 appRequestRefreshRateMax);
451 }
452
453 void onActiveDisplayChanged(const sp<DisplayDevice>& activeDisplay) {
454 Mutex::Autolock lock(mFlinger->mStateLock);
455 mFlinger->onActiveDisplayChangedLocked(activeDisplay);
456 }
457
Lloyd Pique86016da2018-03-01 16:09:38 -0800458 /* ------------------------------------------------------------------------
459 * Read-only access to private data to assert post-conditions.
460 */
461
462 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800463 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800464 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700465 auto& getHwComposer() const {
466 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
467 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700468 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800469
Lloyd Pique86016da2018-03-01 16:09:38 -0800470 const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }
471
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000472 mock::FrameTracer* getFrameTracer() const {
473 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
474 }
475
Ady Abrahame9ebce02022-02-03 12:05:06 -0800476 nsecs_t getAnimationTransactionTimeout() const {
477 return mFlinger->mAnimationTransactionTimeout;
478 }
479
Lloyd Piquef58625d2017-12-19 13:22:33 -0800480 /* ------------------------------------------------------------------------
481 * Read-write access to private data to set up preconditions and assert
482 * post-conditions.
483 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800484
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800485 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
486
Lloyd Piquee39cad22017-12-20 17:01:29 -0800487 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800488 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700489 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800490 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700491 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800492 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800493 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800494 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700495 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700496 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800497 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800498 auto& mutablePowerAdvisor() { return mFlinger->mPowerAdvisor; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700499 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700500 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800501
Lloyd Pique441d5042018-10-18 16:49:51 -0700502 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
503 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700504 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Ady Abrahamadc914c2021-10-13 17:04:27 -0700505 auto& mutableActiveDisplayToken() { return mFlinger->mActiveDisplayToken; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800506
Valerie Hau09e60052019-12-15 14:51:15 -0800507 auto fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -0800508 return mFlinger->fromHandle(handle);
509 }
510
Lloyd Piquee39cad22017-12-20 17:01:29 -0800511 ~TestableSurfaceFlinger() {
512 // All these pointer and container clears help ensure that GMock does
513 // not report a leaked object, since the SurfaceFlinger instance may
514 // still be referenced by something despite our best efforts to destroy
515 // it after each test is done.
516 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800517 mutableCurrentState().displays.clear();
518 mutableDrawingState().displays.clear();
Pablo Gamito5cfc6e52020-09-10 11:18:03 +0000519 mutableInterceptor().clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700520 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700521 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700522 mFlinger->mCompositionEngine->setRenderEngine(
523 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800524 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800525
Lloyd Piquea618d852018-01-17 11:52:30 -0800526 /* ------------------------------------------------------------------------
527 * Wrapper classes for Read-write access to private data to set up
528 * preconditions and assert post-conditions.
529 */
Ana Krulec4593b692019-01-11 22:07:25 -0800530 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800531 HWC2Display(
532 Hwc2::Composer& composer,
533 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
534 capabilities,
535 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800536 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800537 ~HWC2Display() {
538 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700539 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800540 }
541
542 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700543 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800544 };
545
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800546 class FakeHwcDisplayInjector {
547 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700548 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800549 static constexpr int32_t DEFAULT_WIDTH = 1920;
550 static constexpr int32_t DEFAULT_HEIGHT = 1280;
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100551 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800552 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800553 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700554 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700555 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800556
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200557 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
558 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700559 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800560
Peiyong Line9d809e2020-04-14 13:10:48 -0700561 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800562 mHwcDisplayId = displayId;
563 return *this;
564 }
565
566 auto& setWidth(int32_t width) {
567 mWidth = width;
568 return *this;
569 }
570
571 auto& setHeight(int32_t height) {
572 mHeight = height;
573 return *this;
574 }
575
Marin Shalamanov045b7002021-01-07 16:56:24 +0100576 auto& setVsyncPeriod(int32_t vsyncPeriod) {
577 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800578 return *this;
579 }
580
581 auto& setDpiX(int32_t dpi) {
582 mDpiX = dpi;
583 return *this;
584 }
585
586 auto& setDpiY(int32_t dpi) {
587 mDpiY = dpi;
588 return *this;
589 }
590
Peiyong Line9d809e2020-04-14 13:10:48 -0700591 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800592 mActiveConfig = config;
593 return *this;
594 }
595
Ady Abrahamde549d42022-01-26 19:19:17 -0800596 auto& setCapabilities(
597 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
598 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700599 mCapabilities = capabilities;
600 return *this;
601 }
602
Peiyong Lin65248e02020-04-18 21:15:07 -0700603 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700604 mPowerMode = mode;
605 return *this;
606 }
607
Marin Shalamanov045b7002021-01-07 16:56:24 +0100608 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
609 using ::testing::_;
610 using ::testing::DoAll;
611 using ::testing::Return;
612 using ::testing::SetArgPointee;
613
Ady Abrahamde549d42022-01-26 19:19:17 -0800614 static const std::unordered_set<
615 aidl::android::hardware::graphics::composer3::Capability>
616 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700617 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
618
619 // Caution - Make sure that any values passed by reference here do
620 // not refer to an instance owned by FakeHwcDisplayInjector. This
621 // class has temporary lifetime, while the constructed HWC2::Display
622 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800623 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
624 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800625
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800626 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700627 display->setPowerMode(mPowerMode);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800628 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700629
Marin Shalamanov045b7002021-01-07 16:56:24 +0100630 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
631 .WillRepeatedly(
632 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
633 Return(hal::Error::NONE)));
634
635 EXPECT_CALL(*composer,
636 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
637 .WillRepeatedly(DoAll(SetArgPointee<3>(mWidth), Return(hal::Error::NONE)));
638
639 EXPECT_CALL(*composer,
640 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
641 _))
642 .WillRepeatedly(DoAll(SetArgPointee<3>(mHeight), Return(hal::Error::NONE)));
643
644 EXPECT_CALL(*composer,
645 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
646 hal::Attribute::VSYNC_PERIOD, _))
647 .WillRepeatedly(
648 DoAll(SetArgPointee<3>(mVsyncPeriod), Return(hal::Error::NONE)));
649
650 EXPECT_CALL(*composer,
651 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
652 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
653
654 EXPECT_CALL(*composer,
655 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
656 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
657
658 EXPECT_CALL(*composer,
659 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
660 hal::Attribute::CONFIG_GROUP, _))
661 .WillRepeatedly(
662 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100663
Peiyong Line9d809e2020-04-14 13:10:48 -0700664 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200665 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
666 LOG_ALWAYS_FATAL_IF(!physicalId);
667 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100668 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700669 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100670 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700671 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100672 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700673 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
674 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100675 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700676 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800677 }
678
679 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200680 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700681 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700682 const bool mIsPrimary;
683
Peiyong Line9d809e2020-04-14 13:10:48 -0700684 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800685 int32_t mWidth = DEFAULT_WIDTH;
686 int32_t mHeight = DEFAULT_HEIGHT;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100687 int32_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800688 int32_t mDpiX = DEFAULT_DPI;
689 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100690 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700691 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700692 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Ady Abrahamde549d42022-01-26 19:19:17 -0800693 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
694 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800695 };
696
697 class FakeDisplayDeviceInjector {
698 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700699 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Lloyd Pique9370a482019-10-03 17:58:30 -0700700 std::shared_ptr<compositionengine::Display> compositionDisplay,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100701 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700702 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700703 : mFlinger(flinger),
Marin Shalamanov12c9e5a2021-01-07 00:25:35 +0100704 mCreationArgs(flinger.mFlinger.get(), flinger.mFlinger->getHwComposer(),
705 mDisplayToken, compositionDisplay),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100706 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800707 mCreationArgs.connectionType = connectionType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700708 mCreationArgs.isPrimary = isPrimary;
709 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800710
711 sp<IBinder> token() const { return mDisplayToken; }
712
713 DisplayDeviceState& mutableDrawingDisplayState() {
714 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
715 }
716
717 DisplayDeviceState& mutableCurrentDisplayState() {
718 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
719 }
720
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800721 const auto& getDrawingDisplayState() {
722 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
723 }
724
725 const auto& getCurrentDisplayState() {
726 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
727 }
728
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700729 auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800730
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800731 // If `configs` is nullptr, the injector creates RefreshRateConfigs from the `modes`.
732 // Otherwise, it uses `configs`, which the caller must create using the same `modes`.
733 //
734 // TODO(b/182939859): Once `modes` can be retrieved from RefreshRateConfigs, remove
735 // the `configs` parameter in favor of an alternative setRefreshRateConfigs API.
736 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId,
737 std::shared_ptr<scheduler::RefreshRateConfigs> configs = nullptr) {
738 mCreationArgs.supportedModes = std::move(modes);
739 mCreationArgs.activeModeId = activeModeId;
740 mCreationArgs.refreshRateConfigs = std::move(configs);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100741 return *this;
742 }
743
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800744 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700745 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800746 return *this;
747 }
748
Lloyd Pique542307f2018-10-19 13:24:08 -0700749 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700750 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800751 return *this;
752 }
753
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800754 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700755 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800756 return *this;
757 }
758
Peiyong Lin65248e02020-04-18 21:15:07 -0700759 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700760 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700761 return *this;
762 }
763
Valerie Hau9758ae02018-10-09 16:05:09 -0700764 auto& setHwcColorModes(
765 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
766 hwcColorModes) {
767 mCreationArgs.hwcColorModes = hwcColorModes;
768 return *this;
769 }
770
771 auto& setHasWideColorGamut(bool hasWideColorGamut) {
772 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
773 return *this;
774 }
775
Lloyd Pique33050472019-12-19 17:12:44 -0800776 auto& setPhysicalOrientation(ui::Rotation orientation) {
777 mCreationArgs.physicalOrientation = orientation;
778 return *this;
779 }
780
Ady Abraham690f4612021-07-01 23:24:03 -0700781 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800782 auto& modes = mCreationArgs.supportedModes;
783 auto& activeModeId = mCreationArgs.activeModeId;
784
785 if (!mCreationArgs.refreshRateConfigs) {
786 if (modes.empty()) {
787 activeModeId = DisplayModeId(0);
788 modes.emplace_back(
789 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
790 .setId(activeModeId)
791 .setPhysicalDisplayId(PhysicalDisplayId::fromPort(0))
792 .setWidth(FakeHwcDisplayInjector::DEFAULT_WIDTH)
793 .setHeight(FakeHwcDisplayInjector::DEFAULT_HEIGHT)
794 .setVsyncPeriod(FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
795 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
796 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
797 .setGroup(0)
798 .build());
799 }
800
801 mCreationArgs.refreshRateConfigs =
802 std::make_shared<scheduler::RefreshRateConfigs>(modes, activeModeId);
803 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700804
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800805 DisplayDeviceState state;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800806 if (const auto type = mCreationArgs.connectionType) {
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800807 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
Lloyd Pique9370a482019-10-03 17:58:30 -0700808 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200809 const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
810 LOG_ALWAYS_FATAL_IF(!physicalId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100811 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100812
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800813 const auto it = std::find_if(modes.begin(), modes.end(),
814 [&activeModeId](const DisplayModePtr& mode) {
815 return mode->getId() == activeModeId;
816 });
817 LOG_ALWAYS_FATAL_IF(it == modes.end());
818
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100819 state.physical = {.id = *physicalId,
820 .type = *type,
821 .hwcDisplayId = *mHwcDisplayId,
822 .deviceProductInfo = {},
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800823 .supportedModes = modes,
824 .activeMode = *it};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800825 }
826
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700827 state.isSecure = mCreationArgs.isSecure;
828
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800829 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
830 if (!display->isVirtual()) {
831 display->setActiveMode(activeModeId);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100832 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800833 mFlinger.mutableDisplays().emplace(mDisplayToken, display);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800834 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
835 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
836
Dominik Laskowski55c85402020-01-21 16:25:47 -0800837 if (const auto& physical = state.physical) {
838 mFlinger.mutablePhysicalDisplayTokens()[physical->id] = mDisplayToken;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800839 }
840
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800841 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800842 }
843
844 private:
845 TestableSurfaceFlinger& mFlinger;
846 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700847 DisplayDeviceCreationArgs mCreationArgs;
Peiyong Line9d809e2020-04-14 13:10:48 -0700848 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800849 };
850
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700851private:
Lloyd Pique90c115d2018-09-18 21:39:42 -0700852 surfaceflinger::test::Factory mFactory;
853 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800854
855 scheduler::mock::SchedulerCallback mSchedulerCallback;
856 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Dominik Laskowski068173d2021-08-11 17:22:59 -0700857 scheduler::TestableScheduler* mScheduler = nullptr;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800858};
859
860} // namespace android