blob: 81235ba260a0f172934aa16ab921152202c93317 [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 Pique0b785d82018-12-04 17:25:27 -080020#include <compositionengine/Layer.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 Pique0b785d82018-12-04 17:25:27 -080023#include <compositionengine/impl/LayerCompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080024#include <compositionengine/impl/OutputLayerCompositionState.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070025
Lloyd Pique90c115d2018-09-18 21:39:42 -070026#include "BufferQueueLayer.h"
27#include "BufferStateLayer.h"
28#include "ColorLayer.h"
29#include "ContainerLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080030#include "DisplayDevice.h"
Ana Krulec757f63a2019-01-25 10:46:18 -080031#include "FakePhaseOffsets.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070032#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070033#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070034#include "Scheduler/MessageQueue.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070035#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080036#include "SurfaceFlinger.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070037#include "SurfaceFlingerFactory.h"
38#include "SurfaceInterceptor.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080039
Yiwei Zhang7e666a52018-11-15 13:33:42 -080040#include "TimeStats/TimeStats.h"
41
Lloyd Piquef58625d2017-12-19 13:22:33 -080042namespace android {
43
Lloyd Piquee39cad22017-12-20 17:01:29 -080044class EventThread;
45
Peiyong Lin833074a2018-08-28 11:53:54 -070046namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070047
Lloyd Piquee39cad22017-12-20 17:01:29 -080048class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070049
50} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080051
52namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070053
Lloyd Piquee39cad22017-12-20 17:01:29 -080054class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070055
56} // namespace Hwc2
57
58namespace surfaceflinger::test {
59
60class Factory final : public surfaceflinger::Factory {
61public:
62 ~Factory() = default;
63
64 std::unique_ptr<DispSync> createDispSync(const char*, bool, int64_t) override {
65 // TODO: Use test-fixture controlled factory
66 return nullptr;
67 }
68
69 std::unique_ptr<EventControlThread> createEventControlThread(
70 std::function<void(bool)>) override {
71 // TODO: Use test-fixture controlled factory
72 return nullptr;
73 }
74
75 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
76 // TODO: Use test-fixture controlled factory
77 return nullptr;
78 }
79
80 std::unique_ptr<MessageQueue> createMessageQueue() override {
81 // TODO: Use test-fixture controlled factory
82 return std::make_unique<android::impl::MessageQueue>();
83 }
84
Ana Krulec757f63a2019-01-25 10:46:18 -080085 std::unique_ptr<scheduler::PhaseOffsets> createPhaseOffsets() override {
86 return std::make_unique<scheduler::FakePhaseOffsets>();
87 }
88
Lloyd Pique90c115d2018-09-18 21:39:42 -070089 std::unique_ptr<Scheduler> createScheduler(std::function<void(bool)>) override {
90 // TODO: Use test-fixture controlled factory
91 return nullptr;
92 }
93
94 std::unique_ptr<SurfaceInterceptor> createSurfaceInterceptor(SurfaceFlinger* flinger) override {
95 // TODO: Use test-fixture controlled factory
96 return std::make_unique<android::impl::SurfaceInterceptor>(flinger);
97 }
98
99 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
100 // TODO: Use test-fixture controlled factory
101 return new StartPropertySetThread(timestampPropertyValue);
102 }
103
104 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs&& creationArgs) override {
105 // TODO: Use test-fixture controlled factory
106 return new DisplayDevice(std::move(creationArgs));
107 }
108
109 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
110 uint32_t layerCount, uint64_t usage,
111 std::string requestorName) override {
112 // TODO: Use test-fixture controlled factory
113 return new GraphicBuffer(width, height, format, layerCount, usage, requestorName);
114 }
115
116 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
117 sp<IGraphicBufferConsumer>* outConsumer,
118 bool consumerIsSurfaceFlinger) override {
119 if (!mCreateBufferQueue) return;
120 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
121 }
122
123 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
124 const sp<IGraphicBufferProducer>& producer) override {
125 if (!mCreateNativeWindowSurface) return nullptr;
126 return mCreateNativeWindowSurface(producer);
127 }
128
Lloyd Pique70d91362018-10-18 16:02:55 -0700129 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
130 return compositionengine::impl::createCompositionEngine();
131 }
132
Lloyd Pique90c115d2018-09-18 21:39:42 -0700133 sp<BufferQueueLayer> createBufferQueueLayer(const LayerCreationArgs&) override {
134 // TODO: Use test-fixture controlled factory
135 return nullptr;
136 }
137
138 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
139 // TODO: Use test-fixture controlled factory
140 return nullptr;
141 }
142
143 sp<ColorLayer> createColorLayer(const LayerCreationArgs&) override {
144 // TODO: Use test-fixture controlled factory
145 return nullptr;
146 }
147
148 sp<ContainerLayer> createContainerLayer(const LayerCreationArgs&) override {
149 // TODO: Use test-fixture controlled factory
150 return nullptr;
151 }
152
Alec Mourifb571ea2019-01-24 18:42:10 -0800153 std::shared_ptr<TimeStats> createTimeStats() override {
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800154 // TODO: Use test-fixture controlled factory
Alec Mourifb571ea2019-01-24 18:42:10 -0800155 return std::make_shared<android::impl::TimeStats>();
Yiwei Zhang7e666a52018-11-15 13:33:42 -0800156 }
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
Lloyd Piquef58625d2017-12-19 13:22:33 -0800176class TestableSurfaceFlinger {
177public:
178 // Extend this as needed for accessing SurfaceFlinger private (and public)
179 // functions.
180
Peiyong Lin833074a2018-08-28 11:53:54 -0700181 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700182 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800183 }
184
185 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700186 mFlinger->mCompositionEngine->setHwComposer(
187 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800188 }
189
Lloyd Pique90c115d2018-09-18 21:39:42 -0700190 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800191 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700192 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800193 }
194
Lloyd Pique90c115d2018-09-18 21:39:42 -0700195 using CreateNativeWindowSurfaceFunction =
196 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800197 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700198 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800199 }
200
Daniel Solomon42d04562019-01-20 21:03:19 -0800201 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
202 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
203 }
204
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800205 using HotplugEvent = SurfaceFlinger::HotplugEvent;
206
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800207 auto& mutableLayerCurrentState(sp<Layer> layer) { return layer->mCurrentState; }
208 auto& mutableLayerDrawingState(sp<Layer> layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700209
210 void setLayerSidebandStream(sp<Layer> layer, sp<NativeHandle> sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800211 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800212 layer->mSidebandStream = sidebandStream;
213 layer->getCompositionLayer()->editState().frontEnd.sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700214 }
215
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800216 void setLayerCompositionType(sp<Layer> layer, HWC2::Composition type) {
217 auto outputLayer = layer->findOutputLayerForDisplay(mFlinger->getDefaultDisplayDevice());
218 LOG_ALWAYS_FATAL_IF(!outputLayer);
219 auto& state = outputLayer->editState();
220 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
221 (*state.hwc).hwcCompositionType = static_cast<Hwc2::IComposerClient::Composition>(type);
222 };
223
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700224 void setLayerPotentialCursor(sp<Layer> layer, bool potentialCursor) {
225 layer->mPotentialCursor = potentialCursor;
226 }
227
Lloyd Piquef58625d2017-12-19 13:22:33 -0800228 /* ------------------------------------------------------------------------
229 * Forwarding for functions being tested
230 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800231
Lloyd Piquea482f992018-01-22 19:00:34 -0800232 auto createDisplay(const String8& displayName, bool secure) {
233 return mFlinger->createDisplay(displayName, secure);
234 }
235
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700236 auto destroyDisplay(const sp<IBinder>& displayToken) {
237 return mFlinger->destroyDisplay(displayToken);
238 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800239
Lloyd Piqued6fbb8a2018-01-22 19:08:36 -0800240 auto resetDisplayState() { return mFlinger->resetDisplayState(); }
241
Dominik Laskowski075d3172018-05-24 15:50:06 -0700242 auto setupNewDisplayDeviceInternal(const wp<IBinder>& displayToken,
243 const std::optional<DisplayId>& displayId,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800244 const DisplayDeviceState& state,
Lloyd Pique542307f2018-10-19 13:24:08 -0700245 const sp<compositionengine::DisplaySurface>& dispSurface,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800246 const sp<IGraphicBufferProducer>& producer) {
Dominik Laskowski7e045462018-05-30 13:02:02 -0700247 return mFlinger->setupNewDisplayDeviceInternal(displayToken, displayId, state, dispSurface,
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800248 producer);
249 }
250
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800251 auto handleTransactionLocked(uint32_t transactionFlags) {
Vishnu Nairfa5f8df2019-02-13 17:02:51 -0800252 Mutex::Autolock _l(mFlinger->mStateLock);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800253 return mFlinger->handleTransactionLocked(transactionFlags);
254 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800255
Lloyd Pique6cf11032018-01-22 18:57:44 -0800256 auto onHotplugReceived(int32_t sequenceId, hwc2_display_t display,
257 HWC2::Connection connection) {
258 return mFlinger->onHotplugReceived(sequenceId, display, connection);
259 }
260
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800261 auto setDisplayStateLocked(const DisplayState& s) {
262 Mutex::Autolock _l(mFlinger->mStateLock);
263 return mFlinger->setDisplayStateLocked(s);
264 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800265
Dominik Laskowski83b88212018-12-11 13:34:06 -0800266 // Allow reading display state without locking, as if called on the SF main thread.
267 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
268 return mFlinger->onInitializeDisplays();
269 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800270
Dominik Laskowski83b88212018-12-11 13:34:06 -0800271 // Allow reading display state without locking, as if called on the SF main thread.
272 auto setPowerModeInternal(const sp<DisplayDevice>& display,
273 int mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800274 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800275 }
276
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700277 auto onMessageReceived(int32_t what) { return mFlinger->onMessageReceived(what); }
278
279 auto captureScreenImplLocked(const RenderArea& renderArea,
Dominik Laskowski9dab3432019-03-27 13:21:10 -0700280 SurfaceFlinger::TraverseLayersFunction traverseLayers,
281 ANativeWindowBuffer* buffer, bool useIdentityTransform,
282 bool forSystem, int* outSyncFd) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700283 return mFlinger->captureScreenImplLocked(renderArea, traverseLayers, buffer,
284 useIdentityTransform, forSystem, outSyncFd);
285 }
286
chaviw0e3479f2018-09-10 16:49:30 -0700287 auto traverseLayersInDisplay(const sp<const DisplayDevice>& display,
288 const LayerVector::Visitor& visitor) {
289 return mFlinger->SurfaceFlinger::traverseLayersInDisplay(display, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700290 }
291
Daniel Solomon42d04562019-01-20 21:03:19 -0800292 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
293 ui::DisplayPrimaries &primaries) {
294 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
295 }
296
Lloyd Pique86016da2018-03-01 16:09:38 -0800297 /* ------------------------------------------------------------------------
298 * Read-only access to private data to assert post-conditions.
299 */
300
301 const auto& getAnimFrameTracker() const { return mFlinger->mAnimFrameTracker; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800302 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800303 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700304 auto& getHwComposer() const {
305 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
306 }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800307
Lloyd Pique86016da2018-03-01 16:09:38 -0800308 const auto& getCompositorTiming() const { return mFlinger->getBE().mCompositorTiming; }
309
Lloyd Piquef58625d2017-12-19 13:22:33 -0800310 /* ------------------------------------------------------------------------
311 * Read-write access to private data to set up preconditions and assert
312 * post-conditions.
313 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800314
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800315 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
Chia-I Wu304d9cd2018-08-27 14:38:14 -0700316 auto& mutablePrimaryDisplayOrientation() { return SurfaceFlinger::primaryDisplayOrientation; }
Peiyong Lin13effd12018-07-24 17:01:47 -0700317 auto& mutableUseColorManagement() { return SurfaceFlinger::useColorManagement; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800318
Lloyd Piquee39cad22017-12-20 17:01:29 -0800319 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800320 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700321 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800322 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800323 auto& mutableEventQueue() { return mFlinger->mEventQueue; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700324 auto& mutableGeometryInvalid() { return mFlinger->mGeometryInvalid; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800325 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800326 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800327 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700328 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700329 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800330 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800331 auto& mutableUseHwcVirtualDisplays() { return mFlinger->mUseHwcVirtualDisplays; }
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800332 auto& mutablePowerAdvisor() { return mFlinger->mPowerAdvisor; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800333
Lloyd Pique6cf11032018-01-22 18:57:44 -0800334 auto& mutableComposerSequenceId() { return mFlinger->getBE().mComposerSequenceId; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700335 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
336 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
337 auto& mutableInternalHwcDisplayId() { return getHwComposer().mInternalHwcDisplayId; }
338 auto& mutableExternalHwcDisplayId() { return getHwComposer().mExternalHwcDisplayId; }
Ana Krulecafb45842019-02-13 13:33:03 -0800339 auto& mutableScheduler() { return mFlinger->mScheduler; }
340 auto& mutableAppConnectionHandle() { return mFlinger->mAppConnectionHandle; }
341 auto& mutableSfConnectionHandle() { return mFlinger->mSfConnectionHandle; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800342
Lloyd Piquee39cad22017-12-20 17:01:29 -0800343 ~TestableSurfaceFlinger() {
344 // All these pointer and container clears help ensure that GMock does
345 // not report a leaked object, since the SurfaceFlinger instance may
346 // still be referenced by something despite our best efforts to destroy
347 // it after each test is done.
348 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800349 mutableCurrentState().displays.clear();
350 mutableDrawingState().displays.clear();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800351 mutableEventQueue().reset();
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800352 mutableInterceptor().reset();
Ana Krulecafb45842019-02-13 13:33:03 -0800353 mutableScheduler().reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700354 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700355 mFlinger->mCompositionEngine->setRenderEngine(
356 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800357 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800358
Lloyd Piquea618d852018-01-17 11:52:30 -0800359 /* ------------------------------------------------------------------------
360 * Wrapper classes for Read-write access to private data to set up
361 * preconditions and assert post-conditions.
362 */
Ana Krulec4593b692019-01-11 22:07:25 -0800363 struct HWC2Display : public HWC2::impl::Display {
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800364 HWC2Display(Hwc2::Composer& composer,
Lloyd Piquea618d852018-01-17 11:52:30 -0800365 const std::unordered_set<HWC2::Capability>& capabilities, hwc2_display_t id,
366 HWC2::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800367 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800368 ~HWC2Display() {
369 // Prevents a call to disable vsyncs.
370 mType = HWC2::DisplayType::Invalid;
371 }
372
373 auto& mutableIsConnected() { return this->mIsConnected; }
374 auto& mutableConfigs() { return this->mConfigs; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700375 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800376 };
377
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800378 class FakeHwcDisplayInjector {
379 public:
380 static constexpr hwc2_display_t DEFAULT_HWC_DISPLAY_ID = 1000;
381 static constexpr int32_t DEFAULT_WIDTH = 1920;
382 static constexpr int32_t DEFAULT_HEIGHT = 1280;
383 static constexpr int32_t DEFAULT_REFRESH_RATE = 16'666'666;
384 static constexpr int32_t DEFAULT_DPI = 320;
385 static constexpr int32_t DEFAULT_ACTIVE_CONFIG = 0;
386
Dominik Laskowski075d3172018-05-24 15:50:06 -0700387 FakeHwcDisplayInjector(DisplayId displayId, HWC2::DisplayType hwcDisplayType,
388 bool isPrimary)
389 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800390
391 auto& setHwcDisplayId(hwc2_display_t displayId) {
392 mHwcDisplayId = displayId;
393 return *this;
394 }
395
396 auto& setWidth(int32_t width) {
397 mWidth = width;
398 return *this;
399 }
400
401 auto& setHeight(int32_t height) {
402 mHeight = height;
403 return *this;
404 }
405
406 auto& setRefreshRate(int32_t refreshRate) {
407 mRefreshRate = refreshRate;
408 return *this;
409 }
410
411 auto& setDpiX(int32_t dpi) {
412 mDpiX = dpi;
413 return *this;
414 }
415
416 auto& setDpiY(int32_t dpi) {
417 mDpiY = dpi;
418 return *this;
419 }
420
421 auto& setActiveConfig(int32_t config) {
422 mActiveConfig = config;
423 return *this;
424 }
425
Lloyd Piquee22f0332018-07-16 16:35:56 -0700426 auto& setCapabilities(const std::unordered_set<HWC2::Capability>* capabilities) {
427 mCapabilities = capabilities;
428 return *this;
429 }
430
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800431 void inject(TestableSurfaceFlinger* flinger, Hwc2::Composer* composer) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700432 static const std::unordered_set<HWC2::Capability> defaultCapabilities;
433 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
434
435 // Caution - Make sure that any values passed by reference here do
436 // not refer to an instance owned by FakeHwcDisplayInjector. This
437 // class has temporary lifetime, while the constructed HWC2::Display
438 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800439 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
440 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800441
442 auto config = HWC2::Display::Config::Builder(*display, mActiveConfig);
443 config.setWidth(mWidth);
444 config.setHeight(mHeight);
445 config.setVsyncPeriod(mRefreshRate);
446 config.setDpiX(mDpiX);
447 config.setDpiY(mDpiY);
448 display->mutableConfigs().emplace(mActiveConfig, config.build());
449 display->mutableIsConnected() = true;
450
Dominik Laskowski075d3172018-05-24 15:50:06 -0700451 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = display.get();
452
453 if (mHwcDisplayType == HWC2::DisplayType::Physical) {
454 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, mDisplayId);
455 (mIsPrimary ? flinger->mutableInternalHwcDisplayId()
456 : flinger->mutableExternalHwcDisplayId()) = mHwcDisplayId;
457 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800458
459 flinger->mFakeHwcDisplays.push_back(std::move(display));
460 }
461
462 private:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700463 const DisplayId mDisplayId;
464 const HWC2::DisplayType mHwcDisplayType;
465 const bool mIsPrimary;
466
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800467 hwc2_display_t mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
468 int32_t mWidth = DEFAULT_WIDTH;
469 int32_t mHeight = DEFAULT_HEIGHT;
470 int32_t mRefreshRate = DEFAULT_REFRESH_RATE;
471 int32_t mDpiX = DEFAULT_DPI;
472 int32_t mDpiY = DEFAULT_DPI;
473 int32_t mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700474 const std::unordered_set<HWC2::Capability>* mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800475 };
476
477 class FakeDisplayDeviceInjector {
478 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700479 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
480 const std::optional<DisplayId>& displayId, bool isVirtual,
481 bool isPrimary)
482 : mFlinger(flinger), mCreationArgs(flinger.mFlinger.get(), mDisplayToken, displayId) {
483 mCreationArgs.isVirtual = isVirtual;
484 mCreationArgs.isPrimary = isPrimary;
485 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800486
487 sp<IBinder> token() const { return mDisplayToken; }
488
489 DisplayDeviceState& mutableDrawingDisplayState() {
490 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
491 }
492
493 DisplayDeviceState& mutableCurrentDisplayState() {
494 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
495 }
496
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800497 const auto& getDrawingDisplayState() {
498 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
499 }
500
501 const auto& getCurrentDisplayState() {
502 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
503 }
504
Dominik Laskowski9fae1022018-05-29 13:17:40 -0700505 auto& mutableDisplayDevice() { return mFlinger.mutableDisplays()[mDisplayToken]; }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800506
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800507 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700508 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800509 return *this;
510 }
511
Lloyd Pique542307f2018-10-19 13:24:08 -0700512 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700513 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800514 return *this;
515 }
516
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800517 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700518 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800519 return *this;
520 }
521
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700522 auto& setPowerMode(int mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700523 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700524 return *this;
525 }
526
Valerie Hau9758ae02018-10-09 16:05:09 -0700527 auto& setHwcColorModes(
528 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
529 hwcColorModes) {
530 mCreationArgs.hwcColorModes = hwcColorModes;
531 return *this;
532 }
533
534 auto& setHasWideColorGamut(bool hasWideColorGamut) {
535 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
536 return *this;
537 }
538
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800539 sp<DisplayDevice> inject() {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800540 DisplayDeviceState state;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700541 state.displayId = mCreationArgs.isVirtual ? std::nullopt : mCreationArgs.displayId;
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700542 state.isSecure = mCreationArgs.isSecure;
543
544 sp<DisplayDevice> device = new DisplayDevice(std::move(mCreationArgs));
545 mFlinger.mutableDisplays().emplace(mDisplayToken, device);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800546 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
547 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
548
Dominik Laskowski075d3172018-05-24 15:50:06 -0700549 if (!mCreationArgs.isVirtual) {
550 LOG_ALWAYS_FATAL_IF(!state.displayId);
551 mFlinger.mutablePhysicalDisplayTokens()[*state.displayId] = mDisplayToken;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800552 }
553
554 return device;
555 }
556
557 private:
558 TestableSurfaceFlinger& mFlinger;
559 sp<BBinder> mDisplayToken = new BBinder();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700560 DisplayDeviceCreationArgs mCreationArgs;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800561 };
562
Lloyd Pique90c115d2018-09-18 21:39:42 -0700563 surfaceflinger::test::Factory mFactory;
564 sp<SurfaceFlinger> mFlinger = new SurfaceFlinger(mFactory, SurfaceFlinger::SkipInitialization);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800565
566 // We need to keep a reference to these so they are properly destroyed.
567 std::vector<std::unique_ptr<HWC2Display>> mFakeHwcDisplays;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800568};
569
570} // namespace android