blob: 2b8a67df81864c56e4845fac01946d6e6b55d307 [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
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080019#include <compositionengine/Display.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070020#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080021#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070022#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070023#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080024#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070025#include <compositionengine/mock/DisplaySurface.h>
chaviw0ef7caa2021-01-05 11:04:50 -080026#include <gui/ScreenCaptureResults.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070027
Lloyd Pique90c115d2018-09-18 21:39:42 -070028#include "BufferQueueLayer.h"
29#include "BufferStateLayer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070030#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080031#include "DisplayDevice.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080032#include "EffectLayer.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070033#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080034#include "FrameTracer/FrameTracer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070035#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070036#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070037#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070038#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070039#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080040#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070041#include "SurfaceFlingerDefaultFactory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070042#include "SurfaceInterceptor.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070043#include "TestableScheduler.h"
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +020044#include "mock/MockDisplayIdGenerator.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070045#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080046#include "mock/MockFrameTracer.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080047
Lloyd Piquef58625d2017-12-19 13:22:33 -080048namespace android {
49
Lloyd Piquee39cad22017-12-20 17:01:29 -080050class EventThread;
51
Peiyong Lin833074a2018-08-28 11:53:54 -070052namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070053
Lloyd Piquee39cad22017-12-20 17:01:29 -080054class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070055
56} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080057
58namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070059
Lloyd Piquee39cad22017-12-20 17:01:29 -080060class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070061
62} // namespace Hwc2
63
Peiyong Line9d809e2020-04-14 13:10:48 -070064namespace hal = android::hardware::graphics::composer::hal;
65
Lloyd Pique90c115d2018-09-18 21:39:42 -070066namespace surfaceflinger::test {
67
68class Factory final : public surfaceflinger::Factory {
69public:
70 ~Factory() = default;
71
Lloyd Pique90c115d2018-09-18 21:39:42 -070072 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070073 return nullptr;
74 }
75
76 std::unique_ptr<MessageQueue> createMessageQueue() override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070077 return std::make_unique<android::impl::MessageQueue>();
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
Dominik Laskowski8b01cc02020-07-14 19:02:41 -070085 std::unique_ptr<Scheduler> createScheduler(const scheduler::RefreshRateConfigs&,
Ady Abraham3a77a7b2019-12-02 18:46:59 -080086 ISchedulerCallback&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070087 return nullptr;
88 }
89
Pablo Gamitoc351d6f2020-09-17 15:34:26 +000090 sp<SurfaceInterceptor> createSurfaceInterceptor() override {
91 return new android::impl::SurfaceInterceptor();
Lloyd Pique90c115d2018-09-18 21:39:42 -070092 }
93
94 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070095 return new StartPropertySetThread(timestampPropertyValue);
96 }
97
Lloyd Pique9370a482019-10-03 17:58:30 -070098 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
99 return new DisplayDevice(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700100 }
101
102 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
103 uint32_t layerCount, uint64_t usage,
104 std::string requestorName) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700105 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
106 }
107
108 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
109 sp<IGraphicBufferConsumer>* outConsumer,
110 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700111 if (!mCreateBufferQueue) {
112 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
113 return;
114 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700115 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
116 }
117
Lloyd Piquee300b312019-10-03 13:03:45 -0700118 sp<IGraphicBufferProducer> createMonitoredProducer(const sp<IGraphicBufferProducer>& producer,
119 const sp<SurfaceFlinger>& flinger,
120 const wp<Layer>& layer) override {
121 return new MonitoredProducer(producer, flinger, layer);
122 }
123
124 sp<BufferLayerConsumer> createBufferLayerConsumer(const sp<IGraphicBufferConsumer>& consumer,
125 renderengine::RenderEngine& renderEngine,
126 uint32_t textureName, Layer* layer) override {
127 return new BufferLayerConsumer(consumer, renderEngine, textureName, layer);
128 }
129
Lloyd Pique90c115d2018-09-18 21:39:42 -0700130 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
131 const sp<IGraphicBufferProducer>& producer) override {
132 if (!mCreateNativeWindowSurface) return nullptr;
133 return mCreateNativeWindowSurface(producer);
134 }
135
Lloyd Pique70d91362018-10-18 16:02:55 -0700136 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
137 return compositionengine::impl::createCompositionEngine();
138 }
139
Lloyd Pique90c115d2018-09-18 21:39:42 -0700140 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700141 return nullptr;
142 }
143
144 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700145 return nullptr;
146 }
147
Vishnu Nairfa247b12020-02-11 08:58:26 -0800148 sp<EffectLayer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700149
150 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700151 return nullptr;
152 }
153
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800154 std::unique_ptr<FrameTracer> createFrameTracer() override {
155 return std::make_unique<mock::FrameTracer>();
156 }
157
Adithya Srinivasan01189672020-10-20 14:23:05 -0700158 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800159 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
160 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700161 }
162
Lloyd Pique90c115d2018-09-18 21:39:42 -0700163 using CreateBufferQueueFunction =
164 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
165 sp<IGraphicBufferConsumer>* /* outConsumer */,
166 bool /* consumerIsSurfaceFlinger */)>;
167 CreateBufferQueueFunction mCreateBufferQueue;
168
169 using CreateNativeWindowSurfaceFunction =
170 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
171 const sp<IGraphicBufferProducer>&)>;
172 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700173
174 using CreateCompositionEngineFunction =
175 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
176 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700177};
178
179} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800180
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700181class TestableSurfaceFlinger final : private ISchedulerCallback {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800182public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700183 using HotplugEvent = SurfaceFlinger::HotplugEvent;
184
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700185 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700186 TestableScheduler* scheduler() { return mScheduler; }
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200187 mock::DisplayIdGenerator<GpuVirtualDisplayId>& gpuVirtualDisplayIdGenerator() {
188 return mGpuVirtualDisplayIdGenerator;
189 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700190
Lloyd Piquef58625d2017-12-19 13:22:33 -0800191 // Extend this as needed for accessing SurfaceFlinger private (and public)
192 // functions.
193
Peiyong Lin833074a2018-08-28 11:53:54 -0700194 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700195 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800196 }
197
198 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700199 mFlinger->mCompositionEngine->setHwComposer(
200 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800201 }
202
Alec Mourie4034bb2019-11-19 12:45:54 -0800203 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
204 mFlinger->mCompositionEngine->setTimeStats(timeStats);
205 }
206
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700207 // The ISchedulerCallback argument can be nullptr for a no-op implementation.
Ady Abraham8cb21882020-08-26 18:22:05 -0700208 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
209 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700210 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800211 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700212 ISchedulerCallback* callback = nullptr, bool hasMultipleConfigs = false) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100213 DisplayModes configs{
214 DisplayMode::Builder(0).setVsyncPeriod(16'666'667).setConfigGroup(0).build()};
Ady Abrahamabc27602020-04-08 17:20:29 -0700215
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700216 if (hasMultipleConfigs) {
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100217 configs.emplace_back(
218 DisplayMode::Builder(1).setVsyncPeriod(11'111'111).setConfigGroup(0).build());
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700219 }
220
Marin Shalamanov68a94092020-11-24 17:48:00 +0100221 const auto currConfig = HwcConfigIndexType(0);
222 mFlinger->mRefreshRateConfigs =
223 std::make_unique<scheduler::RefreshRateConfigs>(configs, currConfig);
224 const auto currFps =
225 mFlinger->mRefreshRateConfigs->getRefreshRateFromConfigId(currConfig).getFps();
226 mFlinger->mRefreshRateStats =
227 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, currFps,
228 /*powerMode=*/hal::PowerMode::OFF);
Marin Shalamanov526c3382020-12-10 15:22:29 +0100229 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(currFps);
Ady Abraham8287e852020-08-12 14:44:58 -0700230 mFlinger->mVsyncModulator.emplace(mFlinger->mVsyncConfiguration->getCurrentConfigs());
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700231
Ady Abraham8cb21882020-08-26 18:22:05 -0700232 mScheduler = new TestableScheduler(std::move(vsyncController), std::move(vsyncTracker),
Marin Shalamanov27fa3de2020-11-20 16:22:48 +0100233 *mFlinger->mRefreshRateConfigs, *(callback ?: this));
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700234
Dominik Laskowski98041832019-08-01 18:35:59 -0700235 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
236 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700237 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700238 }
239
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700240 void resetScheduler(Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
241
Lloyd Pique90c115d2018-09-18 21:39:42 -0700242 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800243 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700244 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800245 }
246
Lloyd Pique90c115d2018-09-18 21:39:42 -0700247 using CreateNativeWindowSurfaceFunction =
248 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800249 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700250 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800251 }
252
Daniel Solomon42d04562019-01-20 21:03:19 -0800253 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
254 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
255 }
256
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700257 static auto& mutableLayerCurrentState(const sp<Layer>& layer) { return layer->mCurrentState; }
258 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700259
Valerie Haud251afb2019-03-29 14:19:02 -0700260 auto& mutableStateLock() { return mFlinger->mStateLock; }
261
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700262 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
263 const sp<const DisplayDevice>& display) {
264 return layer->findOutputLayerForDisplay(display.get());
265 }
266
267 static void setLayerSidebandStream(const sp<Layer>& layer,
268 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800269 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800270 layer->mSidebandStream = sidebandStream;
Lloyd Piquede196652020-01-22 17:29:58 -0800271 layer->editCompositionState()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700272 }
273
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700274 void setLayerCompositionType(const sp<Layer>& layer, hal::Composition type) {
275 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800276 LOG_ALWAYS_FATAL_IF(!outputLayer);
277 auto& state = outputLayer->editState();
278 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700279 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700280 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800281
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700282 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700283 layer->mPotentialCursor = potentialCursor;
284 }
285
Garfield Tande619fa2020-10-02 17:13:53 -0700286 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
287 layer->mDrawingParent = drawingParent;
288 }
289
Lloyd Piquef58625d2017-12-19 13:22:33 -0800290 /* ------------------------------------------------------------------------
291 * Forwarding for functions being tested
292 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800293
Lloyd Piquea482f992018-01-22 19:00:34 -0800294 auto createDisplay(const String8& displayName, bool secure) {
295 return mFlinger->createDisplay(displayName, secure);
296 }
297
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700298 auto destroyDisplay(const sp<IBinder>& displayToken) {
299 return mFlinger->destroyDisplay(displayToken);
300 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800301
Lloyd Pique9370a482019-10-03 17:58:30 -0700302 auto setupNewDisplayDeviceInternal(
303 const wp<IBinder>& displayToken,
304 std::shared_ptr<compositionengine::Display> compositionDisplay,
305 const DisplayDeviceState& state,
306 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700307 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700308 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
309 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800310 }
311
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800312 auto handleTransactionLocked(uint32_t transactionFlags) {
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800313 Mutex::Autolock _l(mFlinger->mStateLock);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800314 return mFlinger->handleTransactionLocked(transactionFlags);
315 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800316
Peiyong Line9d809e2020-04-14 13:10:48 -0700317 auto onHotplugReceived(int32_t sequenceId, hal::HWDisplayId display,
318 hal::Connection connection) {
Lloyd Pique6cf11032018-01-22 18:57:44 -0800319 return mFlinger->onHotplugReceived(sequenceId, display, connection);
320 }
321
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800322 auto setDisplayStateLocked(const DisplayState& s) {
323 Mutex::Autolock _l(mFlinger->mStateLock);
324 return mFlinger->setDisplayStateLocked(s);
325 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800326
Dominik Laskowski83b88212018-12-11 13:34:06 -0800327 // Allow reading display state without locking, as if called on the SF main thread.
328 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
329 return mFlinger->onInitializeDisplays();
330 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800331
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100332 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
333
Dominik Laskowski83b88212018-12-11 13:34:06 -0800334 // Allow reading display state without locking, as if called on the SF main thread.
335 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700336 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800337 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800338 }
339
Adithya Srinivasan5f683cf2020-09-15 14:21:04 -0700340 auto onMessageReceived(int32_t what) {
341 return mFlinger->onMessageReceived(what, /*vsyncId=*/0, systemTime());
342 }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700343
chaviw426b5c02020-07-27 11:20:15 -0700344 auto renderScreenImplLocked(const RenderArea& renderArea,
345 SurfaceFlinger::TraverseLayersFunction traverseLayers,
chaviwc6ad8af2020-08-03 11:33:30 -0700346 const sp<GraphicBuffer>& buffer, bool forSystem, int* outSyncFd,
347 bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700348 ScreenCaptureResults captureResults;
chaviwc6ad8af2020-08-03 11:33:30 -0700349 return mFlinger->renderScreenImplLocked(renderArea, traverseLayers, buffer, forSystem,
350 outSyncFd, regionSampling, captureResults);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700351 }
352
chaviw4b9d5e12020-08-04 18:30:35 -0700353 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200354 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700355 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700356 }
357
Daniel Solomon42d04562019-01-20 21:03:19 -0800358 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
359 ui::DisplayPrimaries &primaries) {
360 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
361 }
362
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000363 auto& getTransactionQueue() { return mFlinger->mTransactionQueues; }
Valerie Haud251afb2019-03-29 14:19:02 -0700364
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700365 auto setTransactionState(int64_t frameTimelineVsyncId, const Vector<ComposerState>& states,
Valerie Haud251afb2019-03-29 14:19:02 -0700366 const Vector<DisplayState>& displays, uint32_t flags,
367 const sp<IBinder>& applyToken,
368 const InputWindowCommands& inputWindowCommands,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800369 int64_t desiredPresentTime, bool isAutoTimestamp,
370 const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000371 std::vector<ListenerCallbacks>& listenerCallbacks,
372 uint64_t transactionId) {
Ady Abraham22c7b5c2020-09-22 19:33:40 -0700373 return mFlinger->setTransactionState(frameTimelineVsyncId, states, displays, flags,
374 applyToken, inputWindowCommands, desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800375 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
376 listenerCallbacks, transactionId);
Valerie Haud251afb2019-03-29 14:19:02 -0700377 }
378
Zhuoyao Zhang3d3540d2021-01-14 05:14:54 +0000379 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(); };
Valerie Haud251afb2019-03-29 14:19:02 -0700380
Eduardo Rochaac867192020-09-14 20:12:17 +0000381 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
382 return mFlinger->onTransact(code, data, reply, flags);
383 }
384
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800385 auto getGPUContextPriority() { return mFlinger->getGPUContextPriority(); }
386
Lloyd Pique86016da2018-03-01 16:09:38 -0800387 /* ------------------------------------------------------------------------
388 * Read-only access to private data to assert post-conditions.
389 */
390
391 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800392 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800393 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700394 auto& getHwComposer() const {
395 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
396 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700397 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800398
Lloyd Pique86016da2018-03-01 16:09:38 -0800399 const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }
400
Lloyd Piquef58625d2017-12-19 13:22:33 -0800401 /* ------------------------------------------------------------------------
402 * Read-write access to private data to set up preconditions and assert
403 * post-conditions.
404 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800405
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800406 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
Peiyong Lin13effd12018-07-24 17:01:47 -0700407 auto& mutableUseColorManagement() { return SurfaceFlinger::useColorManagement; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800408
Lloyd Piquee39cad22017-12-20 17:01:29 -0800409 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800410 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700411 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800412 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800413 auto& mutableEventQueue() { return mFlinger->mEventQueue; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700414 auto& mutableGeometryInvalid() { return mFlinger->mGeometryInvalid; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800415 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800416 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800417 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700418 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700419 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800420 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800421 auto& mutableUseHwcVirtualDisplays() { return mFlinger->mUseHwcVirtualDisplays; }
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800422 auto& mutablePowerAdvisor() { return mFlinger->mPowerAdvisor; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700423 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800424
Lloyd Pique6cf11032018-01-22 18:57:44 -0800425 auto& mutableComposerSequenceId() { return mFlinger->getBE().mComposerSequenceId; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700426 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
427 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
428 auto& mutableInternalHwcDisplayId() { return getHwComposer().mInternalHwcDisplayId; }
429 auto& mutableExternalHwcDisplayId() { return getHwComposer().mExternalHwcDisplayId; }
Ady Abraham60e42ea2020-03-09 19:17:31 -0700430 auto& mutableUseFrameRateApi() { return mFlinger->useFrameRateApi; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800431
Valerie Hau09e60052019-12-15 14:51:15 -0800432 auto fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -0800433 return mFlinger->fromHandle(handle);
434 }
435
Lloyd Piquee39cad22017-12-20 17:01:29 -0800436 ~TestableSurfaceFlinger() {
437 // All these pointer and container clears help ensure that GMock does
438 // not report a leaked object, since the SurfaceFlinger instance may
439 // still be referenced by something despite our best efforts to destroy
440 // it after each test is done.
441 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800442 mutableCurrentState().displays.clear();
443 mutableDrawingState().displays.clear();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800444 mutableEventQueue().reset();
Pablo Gamito5cfc6e52020-09-10 11:18:03 +0000445 mutableInterceptor().clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700446 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700447 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700448 mFlinger->mCompositionEngine->setRenderEngine(
449 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800450 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800451
Lloyd Piquea618d852018-01-17 11:52:30 -0800452 /* ------------------------------------------------------------------------
453 * Wrapper classes for Read-write access to private data to set up
454 * preconditions and assert post-conditions.
455 */
Ana Krulec4593b692019-01-11 22:07:25 -0800456 struct HWC2Display : public HWC2::impl::Display {
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800457 HWC2Display(Hwc2::Composer& composer,
Peiyong Line9d809e2020-04-14 13:10:48 -0700458 const std::unordered_set<hal::Capability>& capabilities, hal::HWDisplayId id,
459 hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800460 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800461 ~HWC2Display() {
462 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700463 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800464 }
465
466 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700467 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800468 };
469
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800470 class FakeHwcDisplayInjector {
471 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700472 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800473 static constexpr int32_t DEFAULT_WIDTH = 1920;
474 static constexpr int32_t DEFAULT_HEIGHT = 1280;
475 static constexpr int32_t DEFAULT_REFRESH_RATE = 16'666'666;
Ady Abraham2139f732019-11-13 18:56:40 -0800476 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800477 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700478 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700479 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800480
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200481 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
482 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700483 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800484
Peiyong Line9d809e2020-04-14 13:10:48 -0700485 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800486 mHwcDisplayId = displayId;
487 return *this;
488 }
489
490 auto& setWidth(int32_t width) {
491 mWidth = width;
492 return *this;
493 }
494
495 auto& setHeight(int32_t height) {
496 mHeight = height;
497 return *this;
498 }
499
Ady Abraham8a82ba62020-01-17 12:43:17 -0800500 auto& setRefreshRate(int32_t refreshRate) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800501 mRefreshRate = refreshRate;
502 return *this;
503 }
504
505 auto& setDpiX(int32_t dpi) {
506 mDpiX = dpi;
507 return *this;
508 }
509
510 auto& setDpiY(int32_t dpi) {
511 mDpiY = dpi;
512 return *this;
513 }
514
Peiyong Line9d809e2020-04-14 13:10:48 -0700515 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800516 mActiveConfig = config;
517 return *this;
518 }
519
Peiyong Line9d809e2020-04-14 13:10:48 -0700520 auto& setCapabilities(const std::unordered_set<hal::Capability>* capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700521 mCapabilities = capabilities;
522 return *this;
523 }
524
Peiyong Lin65248e02020-04-18 21:15:07 -0700525 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700526 mPowerMode = mode;
527 return *this;
528 }
529
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800530 void inject(TestableSurfaceFlinger* flinger, Hwc2::Composer* composer) {
Peiyong Line9d809e2020-04-14 13:10:48 -0700531 static const std::unordered_set<hal::Capability> defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700532 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
533
534 // Caution - Make sure that any values passed by reference here do
535 // not refer to an instance owned by FakeHwcDisplayInjector. This
536 // class has temporary lifetime, while the constructed HWC2::Display
537 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800538 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
539 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800540
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800541 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700542 display->setPowerMode(mPowerMode);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800543 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700544
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100545 auto config = DisplayMode::Builder(mActiveConfig)
546 .setWidth(mWidth)
547 .setHeight(mHeight)
548 .setVsyncPeriod(mRefreshRate)
549 .setDpiX(mDpiX)
550 .setDpiY(mDpiY)
551 .setConfigGroup(mConfigGroup)
552 .build();
553 flinger->mutableHwcDisplayData()[mDisplayId].modes.push_back(config);
554
Peiyong Line9d809e2020-04-14 13:10:48 -0700555 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200556 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
557 LOG_ALWAYS_FATAL_IF(!physicalId);
558 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100559 if (mIsPrimary) {
560 flinger->mutableInternalHwcDisplayId() = mHwcDisplayId;
561 } else {
562 // If there is an external HWC display there should always be an internal ID
563 // as well. Set it to some arbitrary value.
564 auto& internalId = flinger->mutableInternalHwcDisplayId();
565 if (!internalId) internalId = mHwcDisplayId - 1;
566 flinger->mutableExternalHwcDisplayId() = mHwcDisplayId;
567 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700568 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800569 }
570
571 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200572 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700573 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700574 const bool mIsPrimary;
575
Peiyong Line9d809e2020-04-14 13:10:48 -0700576 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800577 int32_t mWidth = DEFAULT_WIDTH;
578 int32_t mHeight = DEFAULT_HEIGHT;
Ady Abraham8a82ba62020-01-17 12:43:17 -0800579 int32_t mRefreshRate = DEFAULT_REFRESH_RATE;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800580 int32_t mDpiX = DEFAULT_DPI;
Ady Abraham2139f732019-11-13 18:56:40 -0800581 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800582 int32_t mDpiY = DEFAULT_DPI;
Peiyong Line9d809e2020-04-14 13:10:48 -0700583 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700584 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Peiyong Line9d809e2020-04-14 13:10:48 -0700585 const std::unordered_set<hal::Capability>* mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800586 };
587
588 class FakeDisplayDeviceInjector {
589 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700590 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Lloyd Pique9370a482019-10-03 17:58:30 -0700591 std::shared_ptr<compositionengine::Display> compositionDisplay,
Dominik Laskowski55c85402020-01-21 16:25:47 -0800592 std::optional<DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700593 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700594 : mFlinger(flinger),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100595 mCreationArgs(flinger.mFlinger.get(), mDisplayToken, compositionDisplay),
596 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800597 mCreationArgs.connectionType = connectionType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700598 mCreationArgs.isPrimary = isPrimary;
599 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800600
601 sp<IBinder> token() const { return mDisplayToken; }
602
603 DisplayDeviceState& mutableDrawingDisplayState() {
604 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
605 }
606
607 DisplayDeviceState& mutableCurrentDisplayState() {
608 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
609 }
610
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800611 const auto& getDrawingDisplayState() {
612 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
613 }
614
615 const auto& getCurrentDisplayState() {
616 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
617 }
618
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700619 auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800620
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800621 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700622 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800623 return *this;
624 }
625
Lloyd Pique542307f2018-10-19 13:24:08 -0700626 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700627 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800628 return *this;
629 }
630
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800631 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700632 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800633 return *this;
634 }
635
Peiyong Lin65248e02020-04-18 21:15:07 -0700636 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700637 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700638 return *this;
639 }
640
Valerie Hau9758ae02018-10-09 16:05:09 -0700641 auto& setHwcColorModes(
642 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
643 hwcColorModes) {
644 mCreationArgs.hwcColorModes = hwcColorModes;
645 return *this;
646 }
647
648 auto& setHasWideColorGamut(bool hasWideColorGamut) {
649 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
650 return *this;
651 }
652
Lloyd Pique33050472019-12-19 17:12:44 -0800653 auto& setPhysicalOrientation(ui::Rotation orientation) {
654 mCreationArgs.physicalOrientation = orientation;
655 return *this;
656 }
657
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800658 sp<DisplayDevice> inject() {
Lloyd Pique9370a482019-10-03 17:58:30 -0700659 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
660
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800661 DisplayDeviceState state;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800662 if (const auto type = mCreationArgs.connectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -0700663 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200664 const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
665 LOG_ALWAYS_FATAL_IF(!physicalId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100666 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200667 state.physical = {.id = *physicalId, .type = *type, .hwcDisplayId = *mHwcDisplayId};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800668 }
669
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700670 state.isSecure = mCreationArgs.isSecure;
671
Lloyd Pique9370a482019-10-03 17:58:30 -0700672 sp<DisplayDevice> device = new DisplayDevice(mCreationArgs);
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700673 mFlinger.mutableDisplays().emplace(mDisplayToken, device);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800674 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
675 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
676
Dominik Laskowski55c85402020-01-21 16:25:47 -0800677 if (const auto& physical = state.physical) {
678 mFlinger.mutablePhysicalDisplayTokens()[physical->id] = mDisplayToken;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800679 }
680
681 return device;
682 }
683
684 private:
685 TestableSurfaceFlinger& mFlinger;
686 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700687 DisplayDeviceCreationArgs mCreationArgs;
Peiyong Line9d809e2020-04-14 13:10:48 -0700688 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800689 };
690
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700691private:
692 void setVsyncEnabled(bool) override {}
693 void changeRefreshRate(const Scheduler::RefreshRate&, Scheduler::ConfigEvent) override {}
694 void repaintEverythingForHWC() override {}
695 void kernelTimerChanged(bool) override {}
Ady Abraham62a0be22020-12-08 16:54:10 -0800696 void triggerOnFrameRateOverridesChanged() {}
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700697
Lloyd Pique90c115d2018-09-18 21:39:42 -0700698 surfaceflinger::test::Factory mFactory;
699 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700700 TestableScheduler* mScheduler = nullptr;
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200701 mock::DisplayIdGenerator<GpuVirtualDisplayId> mGpuVirtualDisplayIdGenerator;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800702};
703
704} // namespace android