blob: 2a8dda6a1f9fa60287c14cdabff8ed04211d9a34 [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 Pique70d91362018-10-18 16:02:55 -070019#include <compositionengine/impl/CompositionEngine.h>
20
Lloyd Pique90c115d2018-09-18 21:39:42 -070021#include "BufferQueueLayer.h"
22#include "BufferStateLayer.h"
23#include "ColorLayer.h"
24#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080025#include "DisplayDevice.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070026#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070027#include "NativeWindowSurface.h"
28#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080029#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070030#include "SurfaceFlingerFactory.h"
31#include "SurfaceInterceptor.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080032
Yiwei Zhang7e666a52018-11-15 13:33:42 -080033#include "TimeStats/TimeStats.h"
34
Lloyd Piquef58625d2017-12-19 13:22:33 -080035namespace android {
36
Lloyd Piquee39cad22017-12-20 17:01:29 -080037class EventThread;
38
Peiyong Lin833074a2018-08-28 11:53:54 -070039namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070040
Lloyd Piquee39cad22017-12-20 17:01:29 -080041class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070042
43} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080044
45namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070046
Lloyd Piquee39cad22017-12-20 17:01:29 -080047class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070048
49} // namespace Hwc2
50
51namespace surfaceflinger::test {
52
53class Factory final : public surfaceflinger::Factory {
54public:
55 ~Factory() = default;
56
57 std::unique_ptr<DispSync> createDispSync(const char*, bool, int64_t) override {
58 // TODO: Use test-fixture controlled factory
59 return nullptr;
60 }
61
62 std::unique_ptr<EventControlThread> createEventControlThread(
63 std::function<void(bool)>) override {
64 // TODO: Use test-fixture controlled factory
65 return nullptr;
66 }
67
68 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
69 // TODO: Use test-fixture controlled factory
70 return nullptr;
71 }
72
73 std::unique_ptr<MessageQueue> createMessageQueue() override {
74 // TODO: Use test-fixture controlled factory
75 return std::make_unique<android::impl::MessageQueue>();
76 }
77
78 std::unique_ptr<Scheduler> createScheduler(std::function<void(bool)>) override {
79 // TODO: Use test-fixture controlled factory
80 return nullptr;
81 }
82
83 std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(SurfaceFlinger* flinger) override {
84 // TODO: Use test-fixture controlled factory
85 return std::make_unique<android::impl::SurfaceInterceptor>(flinger);
86 }
87
88 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
89 // TODO: Use test-fixture controlled factory
90 return new StartPropertySetThread(timestampPropertyValue);
91 }
92
93 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) override {
94 // TODO: Use test-fixture controlled factory
95 return new DisplayDevice(std::move(creationArgs));
96 }
97
98 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
99 uint32_t layerCount, uint64_t usage,
100 std::string requestorName) override {
101 // TODO: Use test-fixture controlled factory
102 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
103 }
104
105 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
106 sp<IGraphicBufferConsumer>* outConsumer,
107 bool consumerIsSurfaceFlinger) override {
108 if (!mCreateBufferQueue) return;
109 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
110 }
111
112 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
113 const sp<IGraphicBufferProducer>& producer) override {
114 if (!mCreateNativeWindowSurface) return nullptr;
115 return mCreateNativeWindowSurface(producer);
116 }
117
Lloyd Pique70d91362018-10-18 16:02:55 -0700118 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
119 return compositionengine::impl::createCompositionEngine();
120 }
121
Lloyd Pique90c115d2018-09-18 21:39:42 -0700122 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
123 // TODO: Use test-fixture controlled factory
124 return nullptr;
125 }
126
127 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
128 // TODO: Use test-fixture controlled factory
129 return nullptr;
130 }
131
132 sp<ColorLayer> createColorLayer(const LayerCreationArgs&) override {
133 // TODO: Use test-fixture controlled factory
134 return nullptr;
135 }
136
137 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
138 // TODO: Use test-fixture controlled factory
139 return nullptr;
140 }
141
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800142 std::unique_ptr<TimeStats> createTimeStats() override {
143 // TODO: Use test-fixture controlled factory
144 return std::make_unique<TimeStats>();
145 }
146
Lloyd Pique90c115d2018-09-18 21:39:42 -0700147 using CreateBufferQueueFunction =
148 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
149 sp<IGraphicBufferConsumer>* /* outConsumer */,
150 bool /* consumerIsSurfaceFlinger */)>;
151 CreateBufferQueueFunction mCreateBufferQueue;
152
153 using CreateNativeWindowSurfaceFunction =
154 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
155 const sp<IGraphicBufferProducer>&)>;
156 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700157
158 using CreateCompositionEngineFunction =
159 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
160 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700161};
162
163} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800164
Lloyd Piquef58625d2017-12-19 13:22:33 -0800165class TestableSurfaceFlinger {
166public:
167 // 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) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700171 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800172 }
173
174 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700175 mFlinger->mCompositionEngine->setHwComposer(
176 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800177 }
178
Lloyd Pique90c115d2018-09-18 21:39:42 -0700179 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800180 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700181 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800182 }
183
Lloyd Pique90c115d2018-09-18 21:39:42 -0700184 using CreateNativeWindowSurfaceFunction =
185 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800186 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700187 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800188 }
189
190 using HotplugEvent = SurfaceFlinger::HotplugEvent;
191
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800192 auto& mutableLayerCurrentState(sp<Layer> layer) { return layer->mCurrentState; }
193 auto& mutableLayerDrawingState(sp<Layer> layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700194
195 void setLayerSidebandStream(sp<Layer> layer, sp<NativeHandle> sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800196 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700197 layer->getBE().compositionInfo.hwc.sidebandStream = sidebandStream;
198 }
199
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700200 void setLayerPotentialCursor(sp<Layer> layer, bool potentialCursor) {
201 layer->mPotentialCursor = potentialCursor;
202 }
203
Lloyd Piquef58625d2017-12-19 13:22:33 -0800204 /* ------------------------------------------------------------------------
205 * Forwarding for functions being tested
206 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800207
Lloyd Piquea482f992018-01-22 19:00:34 -0800208 auto createDisplay(const String8& displayName, bool secure) {
209 return mFlinger->createDisplay(displayName, secure);
210 }
211
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700212 auto destroyDisplay(const sp<IBinder>& displayToken) {
213 return mFlinger->destroyDisplay(displayToken);
214 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800215
Lloyd Piqued6fbb8a2018-01-22 19:08:36 -0800216 auto resetDisplayState() { return mFlinger->resetDisplayState(); }
217
Dominik Laskowski075d3172018-05-24 15:50:06 -0700218 auto setupNewDisplayDeviceInternal(const wp<IBinder>& displayToken,
219 const std::optional<DisplayId>& displayId,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800220 const DisplayDeviceState& state,
Lloyd Pique542307f2018-10-19 13:24:08 -0700221 const sp<compositionengine::DisplaySurface>& dispSurface,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800222 const sp<IGraphicBufferProducer>& producer) {
Dominik Laskowski7e045462018-05-30 13:02:02 -0700223 return mFlinger->setupNewDisplayDeviceInternal(displayToken, displayId, state, dispSurface,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800224 producer);
225 }
226
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800227 auto handleTransactionLocked(uint32_t transactionFlags) {
228 return mFlinger->handleTransactionLocked(transactionFlags);
229 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800230
Lloyd Pique6cf11032018-01-22 18:57:44 -0800231 auto onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
232 HWC2::Connection connection) {
233 return mFlinger->onHotplugReceived(sequenceId, display, connection);
234 }
235
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800236 auto setDisplayStateLocked(const DisplayState& s) { return mFlinger->setDisplayStateLocked(s); }
237
Dominik Laskowski83b88212018-12-11 13:34:06 -0800238 // Allow reading display state without locking, as if called on the SF main thread.
239 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
240 return mFlinger->onInitializeDisplays();
241 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800242
Dominik Laskowski83b88212018-12-11 13:34:06 -0800243 // Allow reading display state without locking, as if called on the SF main thread.
244 auto setPowerModeInternal(const sp<DisplayDevice>& display,
245 int mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800246 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800247 }
248
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700249 auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what); }
250
251 auto captureScreenImplLocked(const RenderArea& renderArea,
252 TraverseLayersFunction traverseLayers, ANativeWindowBuffer* buffer,
253 bool useIdentityTransform, bool forSystem, int* outSyncFd) {
254 return mFlinger->captureScreenImplLocked(renderArea, traverseLayers, buffer,
255 useIdentityTransform, forSystem, outSyncFd);
256 }
257
chaviw0e3479f2018-09-10 16:49:30 -0700258 auto traverseLayersInDisplay(const sp<const DisplayDevice>& display,
259 const LayerVector::Visitor& visitor) {
260 return mFlinger->SurfaceFlinger::traverseLayersInDisplay(display, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700261 }
262
Lloyd Pique86016da2018-03-01 16:09:38 -0800263 /* ------------------------------------------------------------------------
264 * Read-only access to private data to assert post-conditions.
265 */
266
267 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800268 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
269 const auto& getHWVsyncAvailable() const { return mFlinger->mHWVsyncAvailable; }
270 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700271 auto& getHwComposer() const {
272 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
273 }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800274
Lloyd Pique86016da2018-03-01 16:09:38 -0800275 const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }
276
Lloyd Piquef58625d2017-12-19 13:22:33 -0800277 /* ------------------------------------------------------------------------
278 * Read-write access to private data to set up preconditions and assert
279 * post-conditions.
280 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800281
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800282 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700283 auto& mutablePrimaryDisplayOrientation() { return SurfaceFlinger::primaryDisplayOrientation; }
Peiyong Lin13effd12018-07-24 17:01:47 -0700284 auto& mutableUseColorManagement() { return SurfaceFlinger::useColorManagement; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800285
Lloyd Piquee39cad22017-12-20 17:01:29 -0800286 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800287 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700288 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800289 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800290 auto& mutableEventControlThread() { return mFlinger->mEventControlThread; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800291 auto& mutableEventQueue() { return mFlinger->mEventQueue; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800292 auto& mutableEventThread() { return mFlinger->mEventThread; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700293 auto& mutableGeometryInvalid() { return mFlinger->mGeometryInvalid; }
Lloyd Piqued6fbb8a2018-01-22 19:08:36 -0800294 auto& mutableHWVsyncAvailable() { return mFlinger->mHWVsyncAvailable; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800295 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800296 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800297 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700298 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Pique41be5d22018-06-21 13:11:48 -0700299 auto& mutablePrimaryDispSync() { return mFlinger->mPrimaryDispSync; }
Lloyd Piqued6fbb8a2018-01-22 19:08:36 -0800300 auto& mutablePrimaryHWVsyncEnabled() { return mFlinger->mPrimaryHWVsyncEnabled; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700301 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800302 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800303 auto& mutableUseHwcVirtualDisplays() { return mFlinger->mUseHwcVirtualDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800304
Lloyd Pique6cf11032018-01-22 18:57:44 -0800305 auto& mutableComposerSequenceId() { return mFlinger->getBE().mComposerSequenceId; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700306 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
307 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
308 auto& mutableInternalHwcDisplayId() { return getHwComposer().mInternalHwcDisplayId; }
309 auto& mutableExternalHwcDisplayId() { return getHwComposer().mExternalHwcDisplayId; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800310
Lloyd Piquee39cad22017-12-20 17:01:29 -0800311 ~TestableSurfaceFlinger() {
312 // All these pointer and container clears help ensure that GMock does
313 // not report a leaked object, since the SurfaceFlinger instance may
314 // still be referenced by something despite our best efforts to destroy
315 // it after each test is done.
316 mutableDisplays().clear();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800317 mutableEventControlThread().reset();
318 mutableEventQueue().reset();
Lloyd Piquee39cad22017-12-20 17:01:29 -0800319 mutableEventThread().reset();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800320 mutableInterceptor().reset();
Lloyd Pique41be5d22018-06-21 13:11:48 -0700321 mutablePrimaryDispSync().reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700322 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700323 mFlinger->mCompositionEngine->setRenderEngine(
324 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800325 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800326
Lloyd Piquea618d852018-01-17 11:52:30 -0800327 /* ------------------------------------------------------------------------
328 * Wrapper classes for Read-write access to private data to set up
329 * preconditions and assert post-conditions.
330 */
Michael Wright5d22d4f2018-06-21 02:50:34 +0100331 class FakePowerAdvisor : public Hwc2::PowerAdvisor {
332 public:
333 FakePowerAdvisor() = default;
334 ~FakePowerAdvisor() override = default;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700335 void setExpensiveRenderingExpected(hwc2_display_t, bool) override {}
Michael Wright5d22d4f2018-06-21 02:50:34 +0100336 };
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800337
Ana Krulec4593b692019-01-11 22:07:25 -0800338 struct HWC2Display : public HWC2::impl::Display {
Michael Wright5d22d4f2018-06-21 02:50:34 +0100339 HWC2Display(Hwc2::Composer& composer, Hwc2::PowerAdvisor& advisor,
Lloyd Piquea618d852018-01-17 11:52:30 -0800340 const std::unordered_set<HWC2::Capability>& capabilities, hwc2_display_t id,
341 HWC2::DisplayType type)
Ana Krulec4593b692019-01-11 22:07:25 -0800342 : HWC2::impl::Display(composer, advisor, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800343 ~HWC2Display() {
344 // Prevents a call to disable vsyncs.
345 mType = HWC2::DisplayType::Invalid;
346 }
347
348 auto& mutableIsConnected() { return this->mIsConnected; }
349 auto& mutableConfigs() { return this->mConfigs; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700350 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800351 };
352
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800353 class FakeHwcDisplayInjector {
354 public:
355 static constexpr hwc2_display_t DEFAULT_HWC_DISPLAY_ID = 1000;
356 static constexpr int32_t DEFAULT_WIDTH = 1920;
357 static constexpr int32_t DEFAULT_HEIGHT = 1280;
358 static constexpr int32_t DEFAULT_REFRESH_RATE = 16'666'666;
359 static constexpr int32_t DEFAULT_DPI = 320;
360 static constexpr int32_t DEFAULT_ACTIVE_CONFIG = 0;
361
Dominik Laskowski075d3172018-05-24 15:50:06 -0700362 FakeHwcDisplayInjector(DisplayId displayId, HWC2::DisplayType hwcDisplayType,
363 bool isPrimary)
364 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800365
366 auto& setHwcDisplayId(hwc2_display_t displayId) {
367 mHwcDisplayId = displayId;
368 return *this;
369 }
370
371 auto& setWidth(int32_t width) {
372 mWidth = width;
373 return *this;
374 }
375
376 auto& setHeight(int32_t height) {
377 mHeight = height;
378 return *this;
379 }
380
381 auto& setRefreshRate(int32_t refreshRate) {
382 mRefreshRate = refreshRate;
383 return *this;
384 }
385
386 auto& setDpiX(int32_t dpi) {
387 mDpiX = dpi;
388 return *this;
389 }
390
391 auto& setDpiY(int32_t dpi) {
392 mDpiY = dpi;
393 return *this;
394 }
395
396 auto& setActiveConfig(int32_t config) {
397 mActiveConfig = config;
398 return *this;
399 }
400
Lloyd Piquee22f0332018-07-16 16:35:56 -0700401 auto& setCapabilities(const std::unordered_set<HWC2::Capability>* capabilities) {
402 mCapabilities = capabilities;
403 return *this;
404 }
405
406 auto& setPowerAdvisor(Hwc2::PowerAdvisor* powerAdvisor) {
407 mPowerAdvisor = powerAdvisor;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800408 return *this;
409 }
410
411 void inject(TestableSurfaceFlinger* flinger, Hwc2::Composer* composer) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700412 static FakePowerAdvisor defaultPowerAdvisor;
413 if (mPowerAdvisor == nullptr) mPowerAdvisor = &defaultPowerAdvisor;
414 static const std::unordered_set<HWC2::Capability> defaultCapabilities;
415 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
416
417 // Caution - Make sure that any values passed by reference here do
418 // not refer to an instance owned by FakeHwcDisplayInjector. This
419 // class has temporary lifetime, while the constructed HWC2::Display
420 // is much longer lived.
421 auto display = std::make_unique<HWC2Display>(*composer, *mPowerAdvisor, *mCapabilities,
Michael Wright5d22d4f2018-06-21 02:50:34 +0100422 mHwcDisplayId, mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800423
424 auto config = HWC2::Display::Config::Builder(*display, mActiveConfig);
425 config.setWidth(mWidth);
426 config.setHeight(mHeight);
427 config.setVsyncPeriod(mRefreshRate);
428 config.setDpiX(mDpiX);
429 config.setDpiY(mDpiY);
430 display->mutableConfigs().emplace(mActiveConfig, config.build());
431 display->mutableIsConnected() = true;
432
Dominik Laskowski075d3172018-05-24 15:50:06 -0700433 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = display.get();
434
435 if (mHwcDisplayType == HWC2::DisplayType::Physical) {
436 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, mDisplayId);
437 (mIsPrimary ? flinger->mutableInternalHwcDisplayId()
438 : flinger->mutableExternalHwcDisplayId()) = mHwcDisplayId;
439 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800440
441 flinger->mFakeHwcDisplays.push_back(std::move(display));
442 }
443
444 private:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700445 const DisplayId mDisplayId;
446 const HWC2::DisplayType mHwcDisplayType;
447 const bool mIsPrimary;
448
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800449 hwc2_display_t mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
450 int32_t mWidth = DEFAULT_WIDTH;
451 int32_t mHeight = DEFAULT_HEIGHT;
452 int32_t mRefreshRate = DEFAULT_REFRESH_RATE;
453 int32_t mDpiX = DEFAULT_DPI;
454 int32_t mDpiY = DEFAULT_DPI;
455 int32_t mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700456 const std::unordered_set<HWC2::Capability>* mCapabilities = nullptr;
457 Hwc2::PowerAdvisor* mPowerAdvisor = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800458 };
459
460 class FakeDisplayDeviceInjector {
461 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700462 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
463 const std::optional<DisplayId>& displayId, bool isVirtual,
464 bool isPrimary)
465 : mFlinger(flinger), mCreationArgs(flinger.mFlinger.get(), mDisplayToken, displayId) {
466 mCreationArgs.isVirtual = isVirtual;
467 mCreationArgs.isPrimary = isPrimary;
468 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800469
470 sp<IBinder> token() const { return mDisplayToken; }
471
472 DisplayDeviceState& mutableDrawingDisplayState() {
473 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
474 }
475
476 DisplayDeviceState& mutableCurrentDisplayState() {
477 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
478 }
479
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800480 const auto& getDrawingDisplayState() {
481 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
482 }
483
484 const auto& getCurrentDisplayState() {
485 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
486 }
487
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700488 auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800489
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800490 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700491 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800492 return *this;
493 }
494
Lloyd Pique542307f2018-10-19 13:24:08 -0700495 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700496 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800497 return *this;
498 }
499
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800500 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700501 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800502 return *this;
503 }
504
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700505 auto& setPowerMode(int mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700506 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700507 return *this;
508 }
509
Valerie Hau9758ae02018-10-09 16:05:09 -0700510 auto& setHwcColorModes(
511 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
512 hwcColorModes) {
513 mCreationArgs.hwcColorModes = hwcColorModes;
514 return *this;
515 }
516
517 auto& setHasWideColorGamut(bool hasWideColorGamut) {
518 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
519 return *this;
520 }
521
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800522 sp<DisplayDevice> inject() {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800523 DisplayDeviceState state;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700524 state.displayId = mCreationArgs.isVirtual ? std::nullopt : mCreationArgs.displayId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700525 state.isSecure = mCreationArgs.isSecure;
526
527 sp<DisplayDevice> device = new DisplayDevice(std::move(mCreationArgs));
528 mFlinger.mutableDisplays().emplace(mDisplayToken, device);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800529 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
530 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
531
Dominik Laskowski075d3172018-05-24 15:50:06 -0700532 if (!mCreationArgs.isVirtual) {
533 LOG_ALWAYS_FATAL_IF(!state.displayId);
534 mFlinger.mutablePhysicalDisplayTokens()[*state.displayId] = mDisplayToken;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800535 }
536
537 return device;
538 }
539
540 private:
541 TestableSurfaceFlinger& mFlinger;
542 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700543 DisplayDeviceCreationArgs mCreationArgs;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800544 };
545
Lloyd Pique90c115d2018-09-18 21:39:42 -0700546 surfaceflinger::test::Factory mFactory;
547 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800548
549 // We need to keep a reference to these so they are properly destroyed.
550 std::vector<std::unique_ptr<HWC2Display>> mFakeHwcDisplays;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800551};
552
553} // namespace android