blob: 66eb186a2332893af96d325c51f49df51b1d6679 [file] [log] [blame]
Lloyd Piquef58625d2017-12-19 13:22:33 -08001/*
2 * Copyright (C) 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#pragma once
18
Dominik Laskowski83bd7712022-01-07 14:30:53 -080019#include <algorithm>
Xiang Wang839fe5b2022-04-04 17:39:38 +000020#include <chrono>
Dominik Laskowski83bd7712022-01-07 14:30:53 -080021#include <variant>
22
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080023#include <compositionengine/Display.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070024#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080025#include <compositionengine/OutputLayer.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070026#include <compositionengine/impl/CompositionEngine.h>
Lloyd Pique9370a482019-10-03 17:58:30 -070027#include <compositionengine/impl/Display.h>
Lloyd Pique37c2c9b2018-12-04 17:25:10 -080028#include <compositionengine/impl/OutputLayerCompositionState.h>
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -070029#include <compositionengine/mock/DisplaySurface.h>
chaviw0ef7caa2021-01-05 11:04:50 -080030#include <gui/ScreenCaptureResults.h>
Lloyd Pique70d91362018-10-18 16:02:55 -070031
Lloyd Pique90c115d2018-09-18 21:39:42 -070032#include "BufferStateLayer.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080033#include "DisplayDevice.h"
Vishnu Nairfa247b12020-02-11 08:58:26 -080034#include "EffectLayer.h"
Ady Abrahamc581d3c2020-08-06 17:34:27 -070035#include "FakeVsyncConfiguration.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080036#include "FrameTracer/FrameTracer.h"
Lloyd Piqued6b579f2018-04-06 15:29:10 -070037#include "Layer.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070038#include "NativeWindowSurface.h"
Dominik Laskowski9dab3432019-03-27 13:21:10 -070039#include "Scheduler/MessageQueue.h"
Steven Thomas2bbaabe2019-08-28 16:08:35 -070040#include "Scheduler/RefreshRateConfigs.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070041#include "StartPropertySetThread.h"
Lloyd Piquef58625d2017-12-19 13:22:33 -080042#include "SurfaceFlinger.h"
Lloyd Pique24f3bfe2019-10-02 19:29:10 -070043#include "SurfaceFlingerDefaultFactory.h"
Lloyd Pique90c115d2018-09-18 21:39:42 -070044#include "SurfaceInterceptor.h"
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -070045#include "TestableScheduler.h"
Marin Shalamanov045b7002021-01-07 16:56:24 +010046#include "mock/DisplayHardware/MockComposer.h"
Dominik Laskowskib0054a22022-03-03 09:03:06 -080047#include "mock/DisplayHardware/MockDisplayMode.h"
Adithya Srinivasan01189672020-10-20 14:23:05 -070048#include "mock/MockFrameTimeline.h"
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -080049#include "mock/MockFrameTracer.h"
Dominik Laskowski83bd7712022-01-07 14:30:53 -080050#include "mock/MockSchedulerCallback.h"
Yiwei Zhang7e666a52018-11-15 13:33:42 -080051
Lloyd Piquef58625d2017-12-19 13:22:33 -080052namespace android {
53
Lloyd Piquee39cad22017-12-20 17:01:29 -080054class EventThread;
55
Peiyong Lin833074a2018-08-28 11:53:54 -070056namespace renderengine {
Lloyd Pique90c115d2018-09-18 21:39:42 -070057
Lloyd Piquee39cad22017-12-20 17:01:29 -080058class RenderEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -070059
60} // namespace renderengine
Lloyd Piquee39cad22017-12-20 17:01:29 -080061
62namespace Hwc2 {
Lloyd Pique90c115d2018-09-18 21:39:42 -070063
Lloyd Piquee39cad22017-12-20 17:01:29 -080064class Composer;
Lloyd Pique90c115d2018-09-18 21:39:42 -070065
66} // namespace Hwc2
67
Peiyong Line9d809e2020-04-14 13:10:48 -070068namespace hal = android::hardware::graphics::composer::hal;
69
Lloyd Pique90c115d2018-09-18 21:39:42 -070070namespace surfaceflinger::test {
71
72class Factory final : public surfaceflinger::Factory {
73public:
74 ~Factory() = default;
75
Lloyd Pique90c115d2018-09-18 21:39:42 -070076 std::unique_ptr<HWComposer> createHWComposer(const std::string&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -070077 return nullptr;
78 }
79
Ady Abraham8287e852020-08-12 14:44:58 -070080 std::unique_ptr<scheduler::VsyncConfiguration> createVsyncConfiguration(
Marin Shalamanov526c3382020-12-10 15:22:29 +010081 Fps /*currentRefreshRate*/) override {
Ana Krulec757f63a2019-01-25 10:46:18 -080082 return std::make_unique<scheduler::FakePhaseOffsets>();
83 }
84
Pablo Gamitoc351d6f2020-09-17 15:34:26 +000085 sp<SurfaceInterceptor> createSurfaceInterceptor() override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070086 return sp<android::impl::SurfaceInterceptor>::make();
Lloyd Pique90c115d2018-09-18 21:39:42 -070087 }
88
89 sp<StartPropertySetThread> createStartPropertySetThread(bool timestampPropertyValue) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070090 return sp<StartPropertySetThread>::make(timestampPropertyValue);
Lloyd Pique90c115d2018-09-18 21:39:42 -070091 }
92
Lloyd Pique9370a482019-10-03 17:58:30 -070093 sp<DisplayDevice> createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -070094 return sp<DisplayDevice>::make(creationArgs);
Lloyd Pique90c115d2018-09-18 21:39:42 -070095 }
96
97 sp<GraphicBuffer> createGraphicBuffer(uint32_t width, uint32_t height, PixelFormat format,
98 uint32_t layerCount, uint64_t usage,
99 std::string requestorName) override {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700100 return sp<GraphicBuffer>::make(width, height, format, layerCount, usage, requestorName);
Lloyd Pique90c115d2018-09-18 21:39:42 -0700101 }
102
103 void createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
104 sp<IGraphicBufferConsumer>* outConsumer,
105 bool consumerIsSurfaceFlinger) override {
Lloyd Piquee300b312019-10-03 13:03:45 -0700106 if (!mCreateBufferQueue) {
107 BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
108 return;
109 }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700110 mCreateBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
111 }
112
113 std::unique_ptr<surfaceflinger::NativeWindowSurface> createNativeWindowSurface(
114 const sp<IGraphicBufferProducer>& producer) override {
115 if (!mCreateNativeWindowSurface) return nullptr;
116 return mCreateNativeWindowSurface(producer);
117 }
118
Lloyd Pique70d91362018-10-18 16:02:55 -0700119 std::unique_ptr<compositionengine::CompositionEngine> createCompositionEngine() override {
120 return compositionengine::impl::createCompositionEngine();
121 }
122
Lloyd Pique90c115d2018-09-18 21:39:42 -0700123 sp<BufferStateLayer> createBufferStateLayer(const LayerCreationArgs&) override {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700124 return nullptr;
125 }
126
Vishnu Nairfa247b12020-02-11 08:58:26 -0800127 sp<EffectLayer> createEffectLayer(const LayerCreationArgs&) override { return nullptr; }
Lloyd Pique90c115d2018-09-18 21:39:42 -0700128
Adithya Srinivasan2db3c1b2020-11-18 12:43:17 -0800129 std::unique_ptr<FrameTracer> createFrameTracer() override {
130 return std::make_unique<mock::FrameTracer>();
131 }
132
Adithya Srinivasan01189672020-10-20 14:23:05 -0700133 std::unique_ptr<frametimeline::FrameTimeline> createFrameTimeline(
Adithya Srinivasan9b2ca3e2020-11-10 10:14:17 -0800134 std::shared_ptr<TimeStats> timeStats, pid_t surfaceFlingerPid = 0) override {
135 return std::make_unique<mock::FrameTimeline>(timeStats, surfaceFlingerPid);
Adithya Srinivasan01189672020-10-20 14:23:05 -0700136 }
137
Lloyd Pique90c115d2018-09-18 21:39:42 -0700138 using CreateBufferQueueFunction =
139 std::function<void(sp<IGraphicBufferProducer>* /* outProducer */,
140 sp<IGraphicBufferConsumer>* /* outConsumer */,
141 bool /* consumerIsSurfaceFlinger */)>;
142 CreateBufferQueueFunction mCreateBufferQueue;
143
144 using CreateNativeWindowSurfaceFunction =
145 std::function<std::unique_ptr<surfaceflinger::NativeWindowSurface>(
146 const sp<IGraphicBufferProducer>&)>;
147 CreateNativeWindowSurfaceFunction mCreateNativeWindowSurface;
Lloyd Pique70d91362018-10-18 16:02:55 -0700148
149 using CreateCompositionEngineFunction =
150 std::function<std::unique_ptr<compositionengine::CompositionEngine>()>;
151 CreateCompositionEngineFunction mCreateCompositionEngine;
Lloyd Pique90c115d2018-09-18 21:39:42 -0700152};
153
154} // namespace surfaceflinger::test
Lloyd Piquee39cad22017-12-20 17:01:29 -0800155
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800156class TestableSurfaceFlinger {
Lloyd Piquef58625d2017-12-19 13:22:33 -0800157public:
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700158 using HotplugEvent = SurfaceFlinger::HotplugEvent;
159
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800160 TestableSurfaceFlinger(sp<SurfaceFlinger> flinger = nullptr) : mFlinger(flinger) {
161 if (!mFlinger) {
162 mFlinger = sp<SurfaceFlinger>::make(mFactory, SurfaceFlinger::SkipInitialization);
163 }
Ady Abrahame9ebce02022-02-03 12:05:06 -0800164 mFlinger->mAnimationTransactionTimeout = ms2ns(10);
165 }
166
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700167 SurfaceFlinger* flinger() { return mFlinger.get(); }
Dominik Laskowski068173d2021-08-11 17:22:59 -0700168 scheduler::TestableScheduler* scheduler() { return mScheduler; }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700169
Lloyd Piquef58625d2017-12-19 13:22:33 -0800170 // Extend this as needed for accessing SurfaceFlinger private (and public)
171 // functions.
172
Peiyong Lin833074a2018-08-28 11:53:54 -0700173 void setupRenderEngine(std::unique_ptr<renderengine::RenderEngine> renderEngine) {
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700174 mFlinger->mCompositionEngine->setRenderEngine(std::move(renderEngine));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800175 }
176
177 void setupComposer(std::unique_ptr<Hwc2::Composer> composer) {
Lloyd Pique441d5042018-10-18 16:49:51 -0700178 mFlinger->mCompositionEngine->setHwComposer(
179 std::make_unique<impl::HWComposer>(std::move(composer)));
Lloyd Piquee39cad22017-12-20 17:01:29 -0800180 }
181
Xiang Wang839fe5b2022-04-04 17:39:38 +0000182 void setupPowerAdvisor(std::unique_ptr<Hwc2::PowerAdvisor> powerAdvisor) {
183 mFlinger->mPowerAdvisor = std::move(powerAdvisor);
184 }
185
Alec Mourie4034bb2019-11-19 12:45:54 -0800186 void setupTimeStats(const std::shared_ptr<TimeStats>& timeStats) {
187 mFlinger->mCompositionEngine->setTimeStats(timeStats);
188 }
189
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800190 enum class SchedulerCallbackImpl { kNoOp, kMock };
191
192 static constexpr struct OneDisplayMode {
193 } kOneDisplayMode;
194
195 static constexpr struct TwoDisplayModes {
196 } kTwoDisplayModes;
197
198 using RefreshRateConfigsPtr = std::shared_ptr<scheduler::RefreshRateConfigs>;
199
200 using DisplayModesVariant =
201 std::variant<OneDisplayMode, TwoDisplayModes, RefreshRateConfigsPtr>;
202
Ady Abraham8cb21882020-08-26 18:22:05 -0700203 void setupScheduler(std::unique_ptr<scheduler::VsyncController> vsyncController,
204 std::unique_ptr<scheduler::VSyncTracker> vsyncTracker,
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700205 std::unique_ptr<EventThread> appEventThread,
Ady Abraham8a82ba62020-01-17 12:43:17 -0800206 std::unique_ptr<EventThread> sfEventThread,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800207 SchedulerCallbackImpl callbackImpl = SchedulerCallbackImpl::kNoOp,
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800208 DisplayModesVariant modesVariant = kOneDisplayMode,
209 bool useNiceMock = false) {
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800210 RefreshRateConfigsPtr configs;
211 if (std::holds_alternative<RefreshRateConfigsPtr>(modesVariant)) {
212 configs = std::move(std::get<RefreshRateConfigsPtr>(modesVariant));
213 } else {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800214 constexpr DisplayModeId kModeId60{0};
215 DisplayModes modes = makeModes(mock::createDisplayMode(kModeId60, 60_Hz));
Ady Abrahamabc27602020-04-08 17:20:29 -0700216
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800217 if (std::holds_alternative<TwoDisplayModes>(modesVariant)) {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800218 constexpr DisplayModeId kModeId90{1};
219 modes.try_emplace(kModeId90, mock::createDisplayMode(kModeId90, 90_Hz));
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800220 }
221
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800222 configs = std::make_shared<scheduler::RefreshRateConfigs>(modes, kModeId60);
Dominik Laskowski983f2b52020-06-25 16:54:06 -0700223 }
224
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800225 const auto fps = configs->getActiveMode()->getFps();
226 mFlinger->mVsyncConfiguration = mFactory.createVsyncConfiguration(fps);
Ady Abraham23ea9da2021-07-14 16:32:56 -0700227 mFlinger->mVsyncModulator = sp<scheduler::VsyncModulator>::make(
228 mFlinger->mVsyncConfiguration->getCurrentConfigs());
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800229
Marin Shalamanov68a94092020-11-24 17:48:00 +0100230 mFlinger->mRefreshRateStats =
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800231 std::make_unique<scheduler::RefreshRateStats>(*mFlinger->mTimeStats, fps,
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800232 hal::PowerMode::OFF);
233
234 using Callback = scheduler::ISchedulerCallback;
235 Callback& callback = callbackImpl == SchedulerCallbackImpl::kNoOp
236 ? static_cast<Callback&>(mNoOpSchedulerCallback)
237 : static_cast<Callback&>(mSchedulerCallback);
Steven Thomas2bbaabe2019-08-28 16:08:35 -0700238
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800239 if (useNiceMock) {
240 mScheduler =
241 new testing::NiceMock<scheduler::TestableScheduler>(std::move(vsyncController),
242 std::move(vsyncTracker),
243 std::move(configs),
244 callback);
245 } else {
246 mScheduler = new scheduler::TestableScheduler(std::move(vsyncController),
247 std::move(vsyncTracker),
248 std::move(configs), callback);
249 }
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700250
Dominik Laskowski98041832019-08-01 18:35:59 -0700251 mFlinger->mAppConnectionHandle = mScheduler->createConnection(std::move(appEventThread));
252 mFlinger->mSfConnectionHandle = mScheduler->createConnection(std::move(sfEventThread));
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700253 resetScheduler(mScheduler);
Dominik Laskowski7c9dbf92019-08-01 17:57:31 -0700254 }
255
Dominik Laskowski068173d2021-08-11 17:22:59 -0700256 void resetScheduler(scheduler::Scheduler* scheduler) { mFlinger->mScheduler.reset(scheduler); }
Dominik Laskowskif7a09ed2019-10-07 13:54:18 -0700257
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800258 scheduler::TestableScheduler& mutableScheduler() { return *mScheduler; }
259 scheduler::mock::SchedulerCallback& mockSchedulerCallback() { return mSchedulerCallback; }
Ady Abraham44e9f3b2021-02-16 15:22:58 -0800260
Ady Abraham2739e832022-02-14 17:42:00 -0800261 auto& mutableVsyncModulator() { return mFlinger->mVsyncModulator; }
262
Lloyd Pique90c115d2018-09-18 21:39:42 -0700263 using CreateBufferQueueFunction = surfaceflinger::test::Factory::CreateBufferQueueFunction;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800264 void setCreateBufferQueueFunction(CreateBufferQueueFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700265 mFactory.mCreateBufferQueue = f;
Lloyd Pique5b36f3f2018-01-17 11:57:07 -0800266 }
267
Lloyd Pique90c115d2018-09-18 21:39:42 -0700268 using CreateNativeWindowSurfaceFunction =
269 surfaceflinger::test::Factory::CreateNativeWindowSurfaceFunction;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800270 void setCreateNativeWindowSurface(CreateNativeWindowSurfaceFunction f) {
Lloyd Pique90c115d2018-09-18 21:39:42 -0700271 mFactory.mCreateNativeWindowSurface = f;
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800272 }
273
Daniel Solomon42d04562019-01-20 21:03:19 -0800274 void setInternalDisplayPrimaries(const ui::DisplayPrimaries& primaries) {
275 memcpy(&mFlinger->mInternalDisplayPrimaries, &primaries, sizeof(ui::DisplayPrimaries));
276 }
277
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700278 static auto& mutableLayerDrawingState(const sp<Layer>& layer) { return layer->mDrawingState; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700279
Valerie Haud251afb2019-03-29 14:19:02 -0700280 auto& mutableStateLock() { return mFlinger->mStateLock; }
281
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700282 static auto findOutputLayerForDisplay(const sp<Layer>& layer,
283 const sp<const DisplayDevice>& display) {
284 return layer->findOutputLayerForDisplay(display.get());
285 }
286
287 static void setLayerSidebandStream(const sp<Layer>& layer,
288 const sp<NativeHandle>& sidebandStream) {
Lloyd Pique0449b0f2018-12-20 16:23:45 -0800289 layer->mDrawingState.sidebandStream = sidebandStream;
Lloyd Pique0b785d82018-12-04 17:25:27 -0800290 layer->mSidebandStream = sidebandStream;
Lloyd Piquede196652020-01-22 17:29:58 -0800291 layer->editCompositionState()->sidebandStream = sidebandStream;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700292 }
293
Leon Scroggins III2e1aa182021-12-01 17:33:12 -0500294 void setLayerCompositionType(const sp<Layer>& layer,
295 aidl::android::hardware::graphics::composer3::Composition type) {
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700296 auto outputLayer = findOutputLayerForDisplay(layer, mFlinger->getDefaultDisplayDevice());
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800297 LOG_ALWAYS_FATAL_IF(!outputLayer);
298 auto& state = outputLayer->editState();
299 LOG_ALWAYS_FATAL_IF(!outputLayer->getState().hwc);
Peiyong Line9d809e2020-04-14 13:10:48 -0700300 (*state.hwc).hwcCompositionType = type;
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700301 }
Lloyd Pique37c2c9b2018-12-04 17:25:10 -0800302
Dominik Laskowskib7251f42020-04-20 17:42:59 -0700303 static void setLayerPotentialCursor(const sp<Layer>& layer, bool potentialCursor) {
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700304 layer->mPotentialCursor = potentialCursor;
305 }
306
Garfield Tande619fa2020-10-02 17:13:53 -0700307 static void setLayerDrawingParent(const sp<Layer>& layer, const sp<Layer>& drawingParent) {
Rob Carrc6d2d2b2021-10-25 16:51:49 +0000308 layer->mDrawingParent = drawingParent;
Garfield Tande619fa2020-10-02 17:13:53 -0700309 }
310
Matt Buckley50c44062022-01-17 20:48:10 +0000311 void setPowerHintSessionMode(bool early, bool late) {
312 mFlinger->mPowerHintSessionMode = {.late = late, .early = early};
313 }
314
Lloyd Piquef58625d2017-12-19 13:22:33 -0800315 /* ------------------------------------------------------------------------
316 * Forwarding for functions being tested
317 */
Xiang Wang839fe5b2022-04-04 17:39:38 +0000318
319 nsecs_t commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expectedVSyncTime) {
320 mFlinger->commit(frameTime, vsyncId, expectedVSyncTime);
321 return frameTime;
322 }
323
324 nsecs_t commit(nsecs_t frameTime, int64_t vsyncId) {
325 std::chrono::nanoseconds period = 10ms;
326 return commit(frameTime, vsyncId, frameTime + period.count());
327 }
328
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700329 nsecs_t commit() {
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700330 const nsecs_t now = systemTime();
331 const nsecs_t expectedVsyncTime = now + 10'000'000;
Xiang Wang839fe5b2022-04-04 17:39:38 +0000332 return commit(now, kVsyncId, expectedVsyncTime);
333 }
334
335 void commitAndComposite(const nsecs_t frameTime, const int64_t vsyncId,
336 const nsecs_t expectedVsyncTime) {
337 mFlinger->composite(commit(frameTime, vsyncId, expectedVsyncTime), kVsyncId);
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700338 }
339
Ady Abraham302ebed2022-03-07 16:03:41 -0800340 void commitAndComposite() { mFlinger->composite(commit(), kVsyncId); }
Dominik Laskowskie0e0cde2021-07-30 10:42:05 -0700341
Lloyd Piquea482f992018-01-22 19:00:34 -0800342 auto createDisplay(const String8& displayName, bool secure) {
343 return mFlinger->createDisplay(displayName, secure);
344 }
345
Dominik Laskowskieecd6592018-05-29 10:25:41 -0700346 auto destroyDisplay(const sp<IBinder>& displayToken) {
347 return mFlinger->destroyDisplay(displayToken);
348 }
Lloyd Piquea482f992018-01-22 19:00:34 -0800349
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100350 auto getDisplay(const sp<IBinder>& displayToken) {
351 Mutex::Autolock lock(mFlinger->mStateLock);
352 return mFlinger->getDisplayDeviceLocked(displayToken);
353 }
354
Dominik Laskowski13948602021-03-08 20:48:28 -0800355 void enableHalVirtualDisplays(bool enable) { mFlinger->enableHalVirtualDisplays(enable); }
356
Lloyd Pique9370a482019-10-03 17:58:30 -0700357 auto setupNewDisplayDeviceInternal(
358 const wp<IBinder>& displayToken,
359 std::shared_ptr<compositionengine::Display> compositionDisplay,
360 const DisplayDeviceState& state,
361 const sp<compositionengine::DisplaySurface>& dispSurface,
Dominik Laskowski0a1435d2020-04-21 00:27:31 -0700362 const sp<IGraphicBufferProducer>& producer) NO_THREAD_SAFETY_ANALYSIS {
Lloyd Pique9370a482019-10-03 17:58:30 -0700363 return mFlinger->setupNewDisplayDeviceInternal(displayToken, compositionDisplay, state,
364 dispSurface, producer);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800365 }
366
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700367 auto commitTransactionsLocked(uint32_t transactionFlags) {
368 Mutex::Autolock lock(mFlinger->mStateLock);
369 return mFlinger->commitTransactionsLocked(transactionFlags);
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800370 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800371
Dominik Laskowskiebc8d3a2021-04-16 23:18:31 -0700372 void onComposerHalHotplug(hal::HWDisplayId hwcDisplayId, hal::Connection connection) {
373 mFlinger->onComposerHalHotplug(hwcDisplayId, connection);
Lloyd Pique6cf11032018-01-22 18:57:44 -0800374 }
375
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800376 auto setDisplayStateLocked(const DisplayState& s) {
Dominik Laskowski9e168db2021-05-27 16:05:12 -0700377 Mutex::Autolock lock(mFlinger->mStateLock);
Vishnu Nairce5d0cc2019-02-28 14:38:41 -0800378 return mFlinger->setDisplayStateLocked(s);
379 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800380
Dominik Laskowski83b88212018-12-11 13:34:06 -0800381 // Allow reading display state without locking, as if called on the SF main thread.
382 auto onInitializeDisplays() NO_THREAD_SAFETY_ANALYSIS {
383 return mFlinger->onInitializeDisplays();
384 }
Lloyd Pique86016da2018-03-01 16:09:38 -0800385
Lais Andrade3a6e47d2020-04-02 11:20:16 +0100386 auto notifyPowerBoost(int32_t boostId) { return mFlinger->notifyPowerBoost(boostId); }
387
Alec Mouricdf16792021-12-10 13:16:06 -0800388 auto setDisplayBrightness(const sp<IBinder>& display,
389 const gui::DisplayBrightness& brightness) {
390 return mFlinger->setDisplayBrightness(display, brightness);
391 }
392
Dominik Laskowski83b88212018-12-11 13:34:06 -0800393 // Allow reading display state without locking, as if called on the SF main thread.
394 auto setPowerModeInternal(const sp<DisplayDevice>& display,
Peiyong Lin65248e02020-04-18 21:15:07 -0700395 hal::PowerMode mode) NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskie9774092018-12-11 10:04:24 -0800396 return mFlinger->setPowerModeInternal(display, mode);
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800397 }
398
Robert Carr12a3b9b2022-03-10 09:55:29 -0800399 auto renderScreenImpl(const RenderArea& renderArea,
chaviw426b5c02020-07-27 11:20:15 -0700400 SurfaceFlinger::TraverseLayersFunction traverseLayers,
Alec Mouria90a5702021-04-16 16:36:21 +0000401 const std::shared_ptr<renderengine::ExternalTexture>& buffer,
402 bool forSystem, bool regionSampling) {
chaviw426b5c02020-07-27 11:20:15 -0700403 ScreenCaptureResults captureResults;
Robert Carr12a3b9b2022-03-10 09:55:29 -0800404 return mFlinger->renderScreenImpl(renderArea, traverseLayers, buffer, forSystem,
chaviw17ac24b2021-01-28 18:50:05 -0800405 regionSampling, false /* grayscale */,
406 captureResults);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700407 }
408
chaviw4b9d5e12020-08-04 18:30:35 -0700409 auto traverseLayersInLayerStack(ui::LayerStack layerStack, int32_t uid,
Marin Shalamanov1c434292020-06-12 01:47:29 +0200410 const LayerVector::Visitor& visitor) {
chaviw4b9d5e12020-08-04 18:30:35 -0700411 return mFlinger->SurfaceFlinger::traverseLayersInLayerStack(layerStack, uid, visitor);
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700412 }
413
Daniel Solomon42d04562019-01-20 21:03:19 -0800414 auto getDisplayNativePrimaries(const sp<IBinder>& displayToken,
415 ui::DisplayPrimaries &primaries) {
416 return mFlinger->SurfaceFlinger::getDisplayNativePrimaries(displayToken, primaries);
417 }
418
Vishnu Nair60d902e2022-07-20 02:55:37 +0000419 auto& getTransactionQueue() { return mFlinger->mLocklessTransactionQueue; }
Arthur Hung58144272021-01-16 03:43:53 +0000420 auto& getPendingTransactionQueue() { return mFlinger->mPendingTransactionQueues; }
ramindani4d48f902021-09-20 21:07:45 +0000421 auto& getTransactionCommittedSignals() { return mFlinger->mTransactionCommittedSignals; }
Valerie Haud251afb2019-03-29 14:19:02 -0700422
Siarhei Vishniakoufc434ac2021-01-13 10:28:00 -1000423 auto setTransactionState(
424 const FrameTimelineInfo& frameTimelineInfo, const Vector<ComposerState>& states,
425 const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
426 const InputWindowCommands& inputWindowCommands, int64_t desiredPresentTime,
427 bool isAutoTimestamp, const client_cache_t& uncacheBuffer, bool hasListenerCallbacks,
428 std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId) {
429 return mFlinger->setTransactionState(frameTimelineInfo, states, displays, flags, applyToken,
430 inputWindowCommands, desiredPresentTime,
Ady Abrahamf0c56492020-12-17 18:04:15 -0800431 isAutoTimestamp, uncacheBuffer, hasListenerCallbacks,
432 listenerCallbacks, transactionId);
Valerie Haud251afb2019-03-29 14:19:02 -0700433 }
434
Vishnu Nair7891e962021-11-11 12:07:21 -0800435 auto flushTransactionQueues() { return mFlinger->flushTransactionQueues(0); };
Valerie Haud251afb2019-03-29 14:19:02 -0700436
Eduardo Rochaac867192020-09-14 20:12:17 +0000437 auto onTransact(uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags) {
438 return mFlinger->onTransact(code, data, reply, flags);
439 }
440
Huihong Luo02186fb2022-02-23 14:21:54 -0800441 auto getGpuContextPriority() { return mFlinger->getGpuContextPriority(); }
Ana Krulec31f2b3c2020-12-14 14:30:09 -0800442
Ady Abraham899dcdb2021-06-15 16:56:21 -0700443 auto calculateMaxAcquiredBufferCount(Fps refreshRate,
444 std::chrono::nanoseconds presentLatency) const {
445 return SurfaceFlinger::calculateMaxAcquiredBufferCount(refreshRate, presentLatency);
Ady Abraham564f9de2021-02-03 18:34:33 -0800446 }
447
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100448 auto setDesiredDisplayModeSpecs(const sp<IBinder>& displayToken, ui::DisplayModeId defaultMode,
449 bool allowGroupSwitching, float primaryRefreshRateMin,
450 float primaryRefreshRateMax, float appRequestRefreshRateMin,
451 float appRequestRefreshRateMax) {
452 return mFlinger->setDesiredDisplayModeSpecs(displayToken, defaultMode, allowGroupSwitching,
453 primaryRefreshRateMin, primaryRefreshRateMax,
454 appRequestRefreshRateMin,
455 appRequestRefreshRateMax);
456 }
457
458 void onActiveDisplayChanged(const sp<DisplayDevice>& activeDisplay) {
459 Mutex::Autolock lock(mFlinger->mStateLock);
460 mFlinger->onActiveDisplayChangedLocked(activeDisplay);
461 }
462
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800463 auto createLayer(LayerCreationArgs& args, sp<IBinder>* outHandle,
464 const sp<IBinder>& parentHandle, int32_t* outLayerId,
465 const sp<Layer>& parentLayer, uint32_t* outTransformHint) {
466 return mFlinger->createLayer(args, outHandle, parentHandle, outLayerId, parentLayer,
467 outTransformHint);
468 }
469
470 auto mirrorLayer(const LayerCreationArgs& args, const sp<IBinder>& mirrorFromHandle,
471 sp<IBinder>* outHandle, int32_t* outLayerId) {
472 return mFlinger->mirrorLayer(args, mirrorFromHandle, outHandle, outLayerId);
473 }
474
Lloyd Pique86016da2018-03-01 16:09:38 -0800475 /* ------------------------------------------------------------------------
476 * Read-only access to private data to assert post-conditions.
477 */
478
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800479 const auto& getHasPoweredOff() const { return mFlinger->mHasPoweredOff; }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800480 const auto& getVisibleRegionsDirty() const { return mFlinger->mVisibleRegionsDirty; }
Lloyd Pique441d5042018-10-18 16:49:51 -0700481 auto& getHwComposer() const {
482 return static_cast<impl::HWComposer&>(mFlinger->getHwComposer());
483 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700484 auto& getCompositionEngine() const { return mFlinger->getCompositionEngine(); }
Lloyd Pique7d4aa6c2018-03-01 16:36:35 -0800485
Adithya Srinivasanb238cd52021-02-04 17:54:05 +0000486 mock::FrameTracer* getFrameTracer() const {
487 return static_cast<mock::FrameTracer*>(mFlinger->mFrameTracer.get());
488 }
489
Ady Abrahame9ebce02022-02-03 12:05:06 -0800490 nsecs_t getAnimationTransactionTimeout() const {
491 return mFlinger->mAnimationTransactionTimeout;
492 }
493
Lloyd Piquef58625d2017-12-19 13:22:33 -0800494 /* ------------------------------------------------------------------------
495 * Read-write access to private data to set up preconditions and assert
496 * post-conditions.
497 */
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800498
Dominik Laskowskieb627312022-04-07 09:13:16 -0700499 const auto& displays() const { return mFlinger->mDisplays; }
500 const auto& currentState() const { return mFlinger->mCurrentState; }
501 const auto& drawingState() const { return mFlinger->mDrawingState; }
502 const auto& transactionFlags() const { return mFlinger->mTransactionFlags; }
503 const auto& hwcPhysicalDisplayIdMap() const { return getHwComposer().mPhysicalDisplayIdMap; }
504
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800505 auto& mutableHasWideColorDisplay() { return SurfaceFlinger::hasWideColorDisplay; }
506
Lloyd Piquee39cad22017-12-20 17:01:29 -0800507 auto& mutableCurrentState() { return mFlinger->mCurrentState; }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800508 auto& mutableDisplayColorSetting() { return mFlinger->mDisplayColorSetting; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700509 auto& mutableDisplays() { return mFlinger->mDisplays; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800510 auto& mutableDrawingState() { return mFlinger->mDrawingState; }
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700511 auto& mutableGeometryDirty() { return mFlinger->mGeometryDirty; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800512 auto& mutableInterceptor() { return mFlinger->mInterceptor; }
Lloyd Pique6cf11032018-01-22 18:57:44 -0800513 auto& mutableMainThreadId() { return mFlinger->mMainThreadId; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800514 auto& mutablePendingHotplugEvents() { return mFlinger->mPendingHotplugEvents; }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700515 auto& mutablePhysicalDisplayTokens() { return mFlinger->mPhysicalDisplayTokens; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700516 auto& mutableTexturePool() { return mFlinger->mTexturePool; }
Lloyd Pique0b1fe702018-01-22 18:03:16 -0800517 auto& mutableTransactionFlags() { return mFlinger->mTransactionFlags; }
Lloyd Pique4fe29402019-08-12 16:51:24 -0700518 auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
Garfield Tan9c9c1912021-07-19 12:02:16 -0700519 auto& mutableMaxRenderTargetSize() { return mFlinger->mMaxRenderTargetSize; }
Lloyd Piquee39cad22017-12-20 17:01:29 -0800520
Lloyd Pique441d5042018-10-18 16:49:51 -0700521 auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
522 auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700523 auto& mutablePrimaryHwcDisplayId() { return getHwComposer().mPrimaryHwcDisplayId; }
Ady Abrahamadc914c2021-10-13 17:04:27 -0700524 auto& mutableActiveDisplayToken() { return mFlinger->mActiveDisplayToken; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800525
Valerie Hau09e60052019-12-15 14:51:15 -0800526 auto fromHandle(const sp<IBinder>& handle) {
Valerie Hau09e60052019-12-15 14:51:15 -0800527 return mFlinger->fromHandle(handle);
528 }
529
Lloyd Piquee39cad22017-12-20 17:01:29 -0800530 ~TestableSurfaceFlinger() {
531 // All these pointer and container clears help ensure that GMock does
532 // not report a leaked object, since the SurfaceFlinger instance may
533 // still be referenced by something despite our best efforts to destroy
534 // it after each test is done.
535 mutableDisplays().clear();
Ady Abraham2939f092019-03-04 17:44:06 -0800536 mutableCurrentState().displays.clear();
537 mutableDrawingState().displays.clear();
Pablo Gamito5cfc6e52020-09-10 11:18:03 +0000538 mutableInterceptor().clear();
Lloyd Pique2eb71eb2019-08-13 13:23:03 -0700539 mFlinger->mScheduler.reset();
Lloyd Pique441d5042018-10-18 16:49:51 -0700540 mFlinger->mCompositionEngine->setHwComposer(std::unique_ptr<HWComposer>());
Lloyd Piqueb97e04f2018-10-18 17:07:05 -0700541 mFlinger->mCompositionEngine->setRenderEngine(
542 std::unique_ptr<renderengine::RenderEngine>());
Lloyd Piquee39cad22017-12-20 17:01:29 -0800543 }
Lloyd Piquef58625d2017-12-19 13:22:33 -0800544
Lloyd Piquea618d852018-01-17 11:52:30 -0800545 /* ------------------------------------------------------------------------
546 * Wrapper classes for Read-write access to private data to set up
547 * preconditions and assert post-conditions.
548 */
Ana Krulec4593b692019-01-11 22:07:25 -0800549 struct HWC2Display : public HWC2::impl::Display {
Ady Abrahamde549d42022-01-26 19:19:17 -0800550 HWC2Display(
551 Hwc2::Composer& composer,
552 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
553 capabilities,
554 hal::HWDisplayId id, hal::DisplayType type)
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800555 : HWC2::impl::Display(composer, capabilities, id, type) {}
Lloyd Piquea618d852018-01-17 11:52:30 -0800556 ~HWC2Display() {
557 // Prevents a call to disable vsyncs.
Peiyong Line9d809e2020-04-14 13:10:48 -0700558 mType = hal::DisplayType::INVALID;
Lloyd Piquea618d852018-01-17 11:52:30 -0800559 }
560
561 auto& mutableIsConnected() { return this->mIsConnected; }
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700562 auto& mutableLayers() { return this->mLayers; }
Lloyd Piquea618d852018-01-17 11:52:30 -0800563 };
564
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800565 class FakeHwcDisplayInjector {
566 public:
Peiyong Line9d809e2020-04-14 13:10:48 -0700567 static constexpr hal::HWDisplayId DEFAULT_HWC_DISPLAY_ID = 1000;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800568 static constexpr ui::Size DEFAULT_RESOLUTION{1920, 1280};
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100569 static constexpr int32_t DEFAULT_VSYNC_PERIOD = 16'666'667;
Ady Abraham2139f732019-11-13 18:56:40 -0800570 static constexpr int32_t DEFAULT_CONFIG_GROUP = 7;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800571 static constexpr int32_t DEFAULT_DPI = 320;
Peiyong Line9d809e2020-04-14 13:10:48 -0700572 static constexpr hal::HWConfigId DEFAULT_ACTIVE_CONFIG = 0;
Peiyong Lin65248e02020-04-18 21:15:07 -0700573 static constexpr hal::PowerMode DEFAULT_POWER_MODE = hal::PowerMode::ON;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800574
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200575 FakeHwcDisplayInjector(HalDisplayId displayId, hal::DisplayType hwcDisplayType,
576 bool isPrimary)
Dominik Laskowski075d3172018-05-24 15:50:06 -0700577 : mDisplayId(displayId), mHwcDisplayType(hwcDisplayType), mIsPrimary(isPrimary) {}
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800578
Peiyong Line9d809e2020-04-14 13:10:48 -0700579 auto& setHwcDisplayId(hal::HWDisplayId displayId) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800580 mHwcDisplayId = displayId;
581 return *this;
582 }
583
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800584 auto& setResolution(ui::Size resolution) {
585 mResolution = resolution;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800586 return *this;
587 }
588
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800589 auto& setVsyncPeriod(nsecs_t vsyncPeriod) {
Marin Shalamanov045b7002021-01-07 16:56:24 +0100590 mVsyncPeriod = vsyncPeriod;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800591 return *this;
592 }
593
594 auto& setDpiX(int32_t dpi) {
595 mDpiX = dpi;
596 return *this;
597 }
598
599 auto& setDpiY(int32_t dpi) {
600 mDpiY = dpi;
601 return *this;
602 }
603
Peiyong Line9d809e2020-04-14 13:10:48 -0700604 auto& setActiveConfig(hal::HWConfigId config) {
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800605 mActiveConfig = config;
606 return *this;
607 }
608
Ady Abrahamde549d42022-01-26 19:19:17 -0800609 auto& setCapabilities(
610 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
611 capabilities) {
Lloyd Piquee22f0332018-07-16 16:35:56 -0700612 mCapabilities = capabilities;
613 return *this;
614 }
615
Peiyong Lin65248e02020-04-18 21:15:07 -0700616 auto& setPowerMode(hal::PowerMode mode) {
Peiyong Lin1336e6e2019-05-28 09:23:50 -0700617 mPowerMode = mode;
618 return *this;
619 }
620
Marin Shalamanov045b7002021-01-07 16:56:24 +0100621 void inject(TestableSurfaceFlinger* flinger, Hwc2::mock::Composer* composer) {
622 using ::testing::_;
623 using ::testing::DoAll;
624 using ::testing::Return;
625 using ::testing::SetArgPointee;
626
Ady Abrahamde549d42022-01-26 19:19:17 -0800627 static const std::unordered_set<
628 aidl::android::hardware::graphics::composer3::Capability>
629 defaultCapabilities;
Lloyd Piquee22f0332018-07-16 16:35:56 -0700630 if (mCapabilities == nullptr) mCapabilities = &defaultCapabilities;
631
632 // Caution - Make sure that any values passed by reference here do
633 // not refer to an instance owned by FakeHwcDisplayInjector. This
634 // class has temporary lifetime, while the constructed HWC2::Display
635 // is much longer lived.
Peiyong Lin74ca2f42019-01-14 19:36:57 -0800636 auto display = std::make_unique<HWC2Display>(*composer, *mCapabilities, mHwcDisplayId,
637 mHwcDisplayType);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800638
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800639 display->mutableIsConnected() = true;
Peiyong Lin65248e02020-04-18 21:15:07 -0700640 display->setPowerMode(mPowerMode);
Peiyong Linbdd08cc2019-12-17 21:35:14 -0800641 flinger->mutableHwcDisplayData()[mDisplayId].hwcDisplay = std::move(display);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700642
Marin Shalamanov045b7002021-01-07 16:56:24 +0100643 EXPECT_CALL(*composer, getDisplayConfigs(mHwcDisplayId, _))
644 .WillRepeatedly(
645 DoAll(SetArgPointee<1>(std::vector<hal::HWConfigId>{mActiveConfig}),
646 Return(hal::Error::NONE)));
647
648 EXPECT_CALL(*composer,
649 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::WIDTH, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800650 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getWidth()),
651 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100652
653 EXPECT_CALL(*composer,
654 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::HEIGHT,
655 _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800656 .WillRepeatedly(DoAll(SetArgPointee<3>(mResolution.getHeight()),
657 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100658
659 EXPECT_CALL(*composer,
660 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
661 hal::Attribute::VSYNC_PERIOD, _))
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800662 .WillRepeatedly(DoAll(SetArgPointee<3>(static_cast<int32_t>(mVsyncPeriod)),
663 Return(hal::Error::NONE)));
Marin Shalamanov045b7002021-01-07 16:56:24 +0100664
665 EXPECT_CALL(*composer,
666 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_X, _))
667 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiX), Return(hal::Error::NONE)));
668
669 EXPECT_CALL(*composer,
670 getDisplayAttribute(mHwcDisplayId, mActiveConfig, hal::Attribute::DPI_Y, _))
671 .WillRepeatedly(DoAll(SetArgPointee<3>(mDpiY), Return(hal::Error::NONE)));
672
673 EXPECT_CALL(*composer,
674 getDisplayAttribute(mHwcDisplayId, mActiveConfig,
675 hal::Attribute::CONFIG_GROUP, _))
676 .WillRepeatedly(
677 DoAll(SetArgPointee<3>(mConfigGroup), Return(hal::Error::NONE)));
Marin Shalamanov3ea1d602020-12-16 19:59:39 +0100678
Peiyong Line9d809e2020-04-14 13:10:48 -0700679 if (mHwcDisplayType == hal::DisplayType::PHYSICAL) {
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200680 const auto physicalId = PhysicalDisplayId::tryCast(mDisplayId);
681 LOG_ALWAYS_FATAL_IF(!physicalId);
682 flinger->mutableHwcPhysicalDisplayIdMap().emplace(mHwcDisplayId, *physicalId);
Marin Shalamanov6e840172020-12-14 22:13:28 +0100683 if (mIsPrimary) {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700684 flinger->mutablePrimaryHwcDisplayId() = mHwcDisplayId;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100685 } else {
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700686 // If there is an external HWC display, there should always be a primary ID
Marin Shalamanov6e840172020-12-14 22:13:28 +0100687 // as well. Set it to some arbitrary value.
Dominik Laskowskif8db0f02021-04-19 11:05:25 -0700688 auto& primaryId = flinger->mutablePrimaryHwcDisplayId();
689 if (!primaryId) primaryId = mHwcDisplayId - 1;
Marin Shalamanov6e840172020-12-14 22:13:28 +0100690 }
Dominik Laskowski075d3172018-05-24 15:50:06 -0700691 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800692 }
693
694 private:
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200695 const HalDisplayId mDisplayId;
Peiyong Line9d809e2020-04-14 13:10:48 -0700696 const hal::DisplayType mHwcDisplayType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700697 const bool mIsPrimary;
698
Peiyong Line9d809e2020-04-14 13:10:48 -0700699 hal::HWDisplayId mHwcDisplayId = DEFAULT_HWC_DISPLAY_ID;
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800700 ui::Size mResolution = DEFAULT_RESOLUTION;
701 nsecs_t mVsyncPeriod = DEFAULT_VSYNC_PERIOD;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800702 int32_t mDpiX = DEFAULT_DPI;
703 int32_t mDpiY = DEFAULT_DPI;
Marin Shalamanov045b7002021-01-07 16:56:24 +0100704 int32_t mConfigGroup = DEFAULT_CONFIG_GROUP;
Peiyong Line9d809e2020-04-14 13:10:48 -0700705 hal::HWConfigId mActiveConfig = DEFAULT_ACTIVE_CONFIG;
Peiyong Lin65248e02020-04-18 21:15:07 -0700706 hal::PowerMode mPowerMode = DEFAULT_POWER_MODE;
Ady Abrahamde549d42022-01-26 19:19:17 -0800707 const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>*
708 mCapabilities = nullptr;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800709 };
710
711 class FakeDisplayDeviceInjector {
712 public:
Dominik Laskowski075d3172018-05-24 15:50:06 -0700713 FakeDisplayDeviceInjector(TestableSurfaceFlinger& flinger,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800714 std::shared_ptr<compositionengine::Display> display,
Marin Shalamanov228f46b2021-01-28 21:11:45 +0100715 std::optional<ui::DisplayConnectionType> connectionType,
Peiyong Line9d809e2020-04-14 13:10:48 -0700716 std::optional<hal::HWDisplayId> hwcDisplayId, bool isPrimary)
Lloyd Pique9370a482019-10-03 17:58:30 -0700717 : mFlinger(flinger),
Ady Abrahamd11bade2022-08-01 16:18:03 -0700718 mCreationArgs(flinger.mFlinger, flinger.mFlinger->getHwComposer(), mDisplayToken,
719 display),
Marin Shalamanov700e6392020-02-12 20:22:26 +0100720 mHwcDisplayId(hwcDisplayId) {
Dominik Laskowski55c85402020-01-21 16:25:47 -0800721 mCreationArgs.connectionType = connectionType;
Dominik Laskowski075d3172018-05-24 15:50:06 -0700722 mCreationArgs.isPrimary = isPrimary;
723 }
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800724
725 sp<IBinder> token() const { return mDisplayToken; }
726
727 DisplayDeviceState& mutableDrawingDisplayState() {
728 return mFlinger.mutableDrawingState().displays.editValueFor(mDisplayToken);
729 }
730
731 DisplayDeviceState& mutableCurrentDisplayState() {
732 return mFlinger.mutableCurrentState().displays.editValueFor(mDisplayToken);
733 }
734
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800735 const auto& getDrawingDisplayState() {
736 return mFlinger.mutableDrawingState().displays.valueFor(mDisplayToken);
737 }
738
739 const auto& getCurrentDisplayState() {
740 return mFlinger.mutableCurrentState().displays.valueFor(mDisplayToken);
741 }
742
Dominik Laskowskieb627312022-04-07 09:13:16 -0700743 const sp<DisplayDevice>& mutableDisplayDevice() {
744 return mFlinger.mutableDisplays().get(mDisplayToken)->get();
745 }
Lloyd Pique9d9cf402018-02-16 17:47:13 -0800746
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800747 // If `configs` is nullptr, the injector creates RefreshRateConfigs from the `modes`.
748 // Otherwise, it uses `configs`, which the caller must create using the same `modes`.
749 //
750 // TODO(b/182939859): Once `modes` can be retrieved from RefreshRateConfigs, remove
751 // the `configs` parameter in favor of an alternative setRefreshRateConfigs API.
752 auto& setDisplayModes(DisplayModes modes, DisplayModeId activeModeId,
753 std::shared_ptr<scheduler::RefreshRateConfigs> configs = nullptr) {
754 mCreationArgs.supportedModes = std::move(modes);
755 mCreationArgs.activeModeId = activeModeId;
756 mCreationArgs.refreshRateConfigs = std::move(configs);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100757 return *this;
758 }
759
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800760 auto& setNativeWindow(const sp<ANativeWindow>& nativeWindow) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700761 mCreationArgs.nativeWindow = nativeWindow;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800762 return *this;
763 }
764
Lloyd Pique542307f2018-10-19 13:24:08 -0700765 auto& setDisplaySurface(const sp<compositionengine::DisplaySurface>& displaySurface) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700766 mCreationArgs.displaySurface = displaySurface;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800767 return *this;
768 }
769
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800770 auto& setSecure(bool secure) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700771 mCreationArgs.isSecure = secure;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800772 return *this;
773 }
774
Peiyong Lin65248e02020-04-18 21:15:07 -0700775 auto& setPowerMode(hal::PowerMode mode) {
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700776 mCreationArgs.initialPowerMode = mode;
Lloyd Piqued6b579f2018-04-06 15:29:10 -0700777 return *this;
778 }
779
Valerie Hau9758ae02018-10-09 16:05:09 -0700780 auto& setHwcColorModes(
781 const std::unordered_map<ui::ColorMode, std::vector<ui::RenderIntent>>
782 hwcColorModes) {
783 mCreationArgs.hwcColorModes = hwcColorModes;
784 return *this;
785 }
786
787 auto& setHasWideColorGamut(bool hasWideColorGamut) {
788 mCreationArgs.hasWideColorGamut = hasWideColorGamut;
789 return *this;
790 }
791
Lloyd Pique33050472019-12-19 17:12:44 -0800792 auto& setPhysicalOrientation(ui::Rotation orientation) {
793 mCreationArgs.physicalOrientation = orientation;
794 return *this;
795 }
796
Ady Abraham690f4612021-07-01 23:24:03 -0700797 sp<DisplayDevice> inject() NO_THREAD_SAFETY_ANALYSIS {
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800798 const auto displayId = mCreationArgs.compositionDisplay->getDisplayId();
799
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800800 auto& modes = mCreationArgs.supportedModes;
801 auto& activeModeId = mCreationArgs.activeModeId;
802
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800803 if (displayId && !mCreationArgs.refreshRateConfigs) {
804 if (const auto physicalId = PhysicalDisplayId::tryCast(*displayId)) {
805 if (modes.empty()) {
806 constexpr DisplayModeId kModeId{0};
807 DisplayModePtr mode =
808 DisplayMode::Builder(FakeHwcDisplayInjector::DEFAULT_ACTIVE_CONFIG)
809 .setId(kModeId)
810 .setPhysicalDisplayId(*physicalId)
811 .setResolution(FakeHwcDisplayInjector::DEFAULT_RESOLUTION)
812 .setVsyncPeriod(
813 FakeHwcDisplayInjector::DEFAULT_VSYNC_PERIOD)
814 .setDpiX(FakeHwcDisplayInjector::DEFAULT_DPI)
815 .setDpiY(FakeHwcDisplayInjector::DEFAULT_DPI)
816 .setGroup(FakeHwcDisplayInjector::DEFAULT_CONFIG_GROUP)
817 .build();
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800818
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800819 modes = ftl::init::map(kModeId, std::move(mode));
820 activeModeId = kModeId;
821 }
822
823 mCreationArgs.refreshRateConfigs =
824 std::make_shared<scheduler::RefreshRateConfigs>(modes, activeModeId);
825 }
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800826 }
Lloyd Pique9370a482019-10-03 17:58:30 -0700827
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800828 DisplayDeviceState state;
Dominik Laskowski55c85402020-01-21 16:25:47 -0800829 if (const auto type = mCreationArgs.connectionType) {
Lloyd Pique9370a482019-10-03 17:58:30 -0700830 LOG_ALWAYS_FATAL_IF(!displayId);
Marin Shalamanov0f10d0d2020-08-06 20:04:06 +0200831 const auto physicalId = PhysicalDisplayId::tryCast(*displayId);
832 LOG_ALWAYS_FATAL_IF(!physicalId);
Marin Shalamanov700e6392020-02-12 20:22:26 +0100833 LOG_ALWAYS_FATAL_IF(!mHwcDisplayId);
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100834
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800835 const auto activeMode = modes.get(activeModeId);
836 LOG_ALWAYS_FATAL_IF(!activeMode);
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800837
Marin Shalamanovc7e9f822021-11-16 20:07:55 +0100838 state.physical = {.id = *physicalId,
839 .type = *type,
840 .hwcDisplayId = *mHwcDisplayId,
841 .deviceProductInfo = {},
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800842 .supportedModes = modes,
Dominik Laskowskib0054a22022-03-03 09:03:06 -0800843 .activeMode = activeMode->get()};
Dominik Laskowski55c85402020-01-21 16:25:47 -0800844 }
845
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700846 state.isSecure = mCreationArgs.isSecure;
847
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800848 sp<DisplayDevice> display = sp<DisplayDevice>::make(mCreationArgs);
849 if (!display->isVirtual()) {
850 display->setActiveMode(activeModeId);
Marin Shalamanov045b7002021-01-07 16:56:24 +0100851 }
Dominik Laskowskieb627312022-04-07 09:13:16 -0700852 mFlinger.mutableDisplays().emplace_or_replace(mDisplayToken, display);
853
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800854 mFlinger.mutableCurrentState().displays.add(mDisplayToken, state);
855 mFlinger.mutableDrawingState().displays.add(mDisplayToken, state);
856
Dominik Laskowski55c85402020-01-21 16:25:47 -0800857 if (const auto& physical = state.physical) {
Dominik Laskowskieb627312022-04-07 09:13:16 -0700858 mFlinger.mutablePhysicalDisplayTokens().emplace_or_replace(physical->id,
859 mDisplayToken);
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800860 }
861
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800862 return display;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800863 }
864
865 private:
866 TestableSurfaceFlinger& mFlinger;
Ady Abrahamd11bade2022-08-01 16:18:03 -0700867 sp<BBinder> mDisplayToken = sp<BBinder>::make();
Lloyd Pique2eef1d22018-09-18 21:30:04 -0700868 DisplayDeviceCreationArgs mCreationArgs;
Peiyong Line9d809e2020-04-14 13:10:48 -0700869 const std::optional<hal::HWDisplayId> mHwcDisplayId;
Lloyd Piquec11e0d32018-01-22 18:44:59 -0800870 };
871
Dominik Laskowski8b01cc02020-07-14 19:02:41 -0700872private:
Ady Abraham302ebed2022-03-07 16:03:41 -0800873 constexpr static int64_t kVsyncId = 123;
874
Lloyd Pique90c115d2018-09-18 21:39:42 -0700875 surfaceflinger::test::Factory mFactory;
Vishnu Nair4df8eb62022-02-17 15:32:02 -0800876 sp<SurfaceFlinger> mFlinger;
Dominik Laskowski83bd7712022-01-07 14:30:53 -0800877 scheduler::mock::SchedulerCallback mSchedulerCallback;
878 scheduler::mock::NoOpSchedulerCallback mNoOpSchedulerCallback;
Dominik Laskowski068173d2021-08-11 17:22:59 -0700879 scheduler::TestableScheduler* mScheduler = nullptr;
Lloyd Piquef58625d2017-12-19 13:22:33 -0800880};
881
882} // namespace android