1 /*
2 * Copyright 2021 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 #undef LOG_TAG
18 #define LOG_TAG "FpsReporterTest"
19
20 #include <chrono>
21
22 #include <android/gui/BnFpsListener.h>
23 #include <gmock/gmock.h>
24 #include <gtest/gtest.h>
25 #include <gui/LayerMetadata.h>
26
27 #include "Client.h" // temporarily needed for LayerCreationArgs
28 #include "FpsReporter.h"
29 #include "FrontEnd/LayerCreationArgs.h"
30 #include "FrontEnd/LayerHierarchy.h"
31 #include "FrontEnd/LayerLifecycleManager.h"
32 #include "Layer.h"
33 #include "TestableSurfaceFlinger.h"
34 #include "fake/FakeClock.h"
35 #include "mock/DisplayHardware/MockComposer.h"
36 #include "mock/MockFrameTimeline.h"
37
38 namespace android {
39
40 using namespace std::chrono_literals;
41
42 using testing::_;
43 using testing::DoAll;
44 using testing::Mock;
45 using testing::Return;
46 using testing::SetArgPointee;
47 using testing::UnorderedElementsAre;
48
49 using android::Hwc2::IComposer;
50 using android::Hwc2::IComposerClient;
51
52 using gui::LayerMetadata;
53
54 struct TestableFpsListener : public gui::BnFpsListener {
TestableFpsListenerandroid::TestableFpsListener55 TestableFpsListener() {}
56
57 float lastReportedFps = 0;
58
onFpsReportedandroid::TestableFpsListener59 binder::Status onFpsReported(float fps) override {
60 lastReportedFps = fps;
61 return binder::Status::ok();
62 }
63 };
64
65 /**
66 * This class covers all the test that are related to refresh rate selection.
67 */
68 class FpsReporterTest : public testing::Test {
69 public:
70 FpsReporterTest();
71 ~FpsReporterTest() override;
72
73 protected:
74 static constexpr int DEFAULT_DISPLAY_WIDTH = 1920;
75 static constexpr int DEFAULT_DISPLAY_HEIGHT = 1024;
76 static constexpr uint32_t WIDTH = 100;
77 static constexpr uint32_t HEIGHT = 100;
78 static constexpr uint32_t LAYER_FLAGS = 0;
79 static constexpr int32_t PRIORITY_UNSET = -1;
80
81 sp<Layer> createBufferStateLayer(LayerMetadata metadata);
82
83 LayerCreationArgs createArgs(uint32_t id, bool canBeRoot, uint32_t parentId,
84 LayerMetadata metadata);
85
86 void createRootLayer(uint32_t id, LayerMetadata metadata);
87
88 void createLayer(uint32_t id, uint32_t parentId, LayerMetadata metadata);
89
90 frontend::LayerLifecycleManager mLifecycleManager;
91
92 mock::FrameTimeline mFrameTimeline =
93 mock::FrameTimeline(std::make_shared<impl::TimeStats>(), 0);
94
95 sp<Client> mClient;
96 sp<Layer> mParent;
97 sp<Layer> mTarget;
98 sp<Layer> mChild;
99 sp<Layer> mGrandChild;
100 sp<Layer> mUnrelated;
101
102 sp<TestableFpsListener> mFpsListener;
103 fake::FakeClock* mClock = new fake::FakeClock();
104 sp<FpsReporter> mFpsReporter =
105 sp<FpsReporter>::make(mFrameTimeline, std::unique_ptr<Clock>(mClock));
106 };
107
FpsReporterTest()108 FpsReporterTest::FpsReporterTest() {
109 const ::testing::TestInfo* const test_info =
110 ::testing::UnitTest::GetInstance()->current_test_info();
111 ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
112
113 mFpsListener = sp<TestableFpsListener>::make();
114 }
115
~FpsReporterTest()116 FpsReporterTest::~FpsReporterTest() {
117 const ::testing::TestInfo* const test_info =
118 ::testing::UnitTest::GetInstance()->current_test_info();
119 ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
120 }
121
createArgs(uint32_t id,bool canBeRoot,uint32_t parentId,LayerMetadata metadata)122 LayerCreationArgs FpsReporterTest::createArgs(uint32_t id, bool canBeRoot, uint32_t parentId,
123 LayerMetadata metadata) {
124 sp<Client> client;
125 LayerCreationArgs args(std::make_optional(id));
126 args.name = "testlayer";
127 args.addToRoot = canBeRoot;
128 args.flags = LAYER_FLAGS;
129 args.metadata = metadata;
130 args.parentId = parentId;
131 return args;
132 }
133
createRootLayer(uint32_t id,LayerMetadata metadata=LayerMetadata ())134 void FpsReporterTest::createRootLayer(uint32_t id, LayerMetadata metadata = LayerMetadata()) {
135 std::vector<std::unique_ptr<frontend::RequestedLayerState>> layers;
136 layers.emplace_back(std::make_unique<frontend::RequestedLayerState>(
137 createArgs(/*id=*/id, /*canBeRoot=*/true, /*parent=*/UNASSIGNED_LAYER_ID,
138 /*metadata=*/metadata)));
139 mLifecycleManager.addLayers(std::move(layers));
140 }
141
createLayer(uint32_t id,uint32_t parentId,LayerMetadata metadata=LayerMetadata ())142 void FpsReporterTest::createLayer(uint32_t id, uint32_t parentId,
143 LayerMetadata metadata = LayerMetadata()) {
144 std::vector<std::unique_ptr<frontend::RequestedLayerState>> layers;
145 layers.emplace_back(std::make_unique<frontend::RequestedLayerState>(
146 createArgs(/*id=*/id, /*canBeRoot=*/false, /*parent=*/parentId,
147 /*mirror=*/metadata)));
148 mLifecycleManager.addLayers(std::move(layers));
149 }
150
151 namespace {
152
TEST_F(FpsReporterTest,callsListeners)153 TEST_F(FpsReporterTest, callsListeners) {
154 constexpr int32_t kTaskId = 12;
155 LayerMetadata targetMetadata;
156 targetMetadata.setInt32(gui::METADATA_TASK_ID, kTaskId);
157
158 createRootLayer(1, targetMetadata);
159 createLayer(11, 1);
160 createLayer(111, 11);
161
162 frontend::LayerHierarchyBuilder hierarchyBuilder;
163 hierarchyBuilder.update(mLifecycleManager);
164
165 float expectedFps = 44.0;
166
167 EXPECT_CALL(mFrameTimeline, computeFps(UnorderedElementsAre(1, 11, 111)))
168 .WillOnce(Return(expectedFps));
169
170 mFpsReporter->addListener(mFpsListener, kTaskId);
171 mClock->advanceTime(600ms);
172 mFpsReporter->dispatchLayerFps(hierarchyBuilder.getHierarchy());
173 EXPECT_EQ(expectedFps, mFpsListener->lastReportedFps);
174 mFpsReporter->removeListener(mFpsListener);
175 Mock::VerifyAndClearExpectations(&mFrameTimeline);
176
177 EXPECT_CALL(mFrameTimeline, computeFps(_)).Times(0);
178 mFpsReporter->dispatchLayerFps(hierarchyBuilder.getHierarchy());
179 }
180
TEST_F(FpsReporterTest,rateLimits)181 TEST_F(FpsReporterTest, rateLimits) {
182 const constexpr int32_t kTaskId = 12;
183 LayerMetadata targetMetadata;
184 targetMetadata.setInt32(gui::METADATA_TASK_ID, kTaskId);
185 createRootLayer(1);
186 createLayer(11, 1, targetMetadata);
187
188 frontend::LayerHierarchyBuilder hierarchyBuilder;
189 hierarchyBuilder.update(mLifecycleManager);
190
191 float firstFps = 44.0;
192 float secondFps = 53.0;
193
194 EXPECT_CALL(mFrameTimeline, computeFps(UnorderedElementsAre(11)))
195 .WillOnce(Return(firstFps))
196 .WillOnce(Return(secondFps));
197
198 mFpsReporter->addListener(mFpsListener, kTaskId);
199 mClock->advanceTime(600ms);
200 mFpsReporter->dispatchLayerFps(hierarchyBuilder.getHierarchy());
201 EXPECT_EQ(firstFps, mFpsListener->lastReportedFps);
202 mClock->advanceTime(200ms);
203 mFpsReporter->dispatchLayerFps(hierarchyBuilder.getHierarchy());
204 EXPECT_EQ(firstFps, mFpsListener->lastReportedFps);
205 mClock->advanceTime(200ms);
206 mFpsReporter->dispatchLayerFps(hierarchyBuilder.getHierarchy());
207 EXPECT_EQ(firstFps, mFpsListener->lastReportedFps);
208 mClock->advanceTime(200ms);
209 mFpsReporter->dispatchLayerFps(hierarchyBuilder.getHierarchy());
210 EXPECT_EQ(secondFps, mFpsListener->lastReportedFps);
211 }
212
213 } // namespace
214 } // namespace android
215