• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2022 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 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 
20 #include "Client.h" // temporarily needed for LayerCreationArgs
21 #include "FrontEnd/LayerCreationArgs.h"
22 #include "FrontEnd/LayerHierarchy.h"
23 #include "FrontEnd/LayerLifecycleManager.h"
24 
25 namespace android::surfaceflinger::frontend {
26 
27 class LayerHierarchyTestBase : public testing::Test {
28 protected:
LayerHierarchyTestBase()29     LayerHierarchyTestBase() {
30         // tree with 3 levels of children
31         // ROOT
32         // ├── 1
33         // │   ├── 11
34         // │   │   └── 111
35         // │   ├── 12
36         // │   │   ├── 121
37         // │   │   └── 122
38         // │   │       └── 1221
39         // │   └── 13
40         // └── 2
41 
42         createRootLayer(1);
43         createRootLayer(2);
44         createLayer(11, 1);
45         createLayer(12, 1);
46         createLayer(13, 1);
47         createLayer(111, 11);
48         createLayer(121, 12);
49         createLayer(122, 12);
50         createLayer(1221, 122);
51     }
52 
createArgs(uint32_t id,bool canBeRoot,uint32_t parentId,uint32_t layerIdToMirror)53     LayerCreationArgs createArgs(uint32_t id, bool canBeRoot, uint32_t parentId,
54                                  uint32_t layerIdToMirror) {
55         LayerCreationArgs args(std::make_optional(id));
56         args.name = "testlayer";
57         args.addToRoot = canBeRoot;
58         args.parentId = parentId;
59         args.layerIdToMirror = layerIdToMirror;
60         return args;
61     }
62 
createDisplayMirrorArgs(uint32_t id,ui::LayerStack layerStackToMirror)63     LayerCreationArgs createDisplayMirrorArgs(uint32_t id, ui::LayerStack layerStackToMirror) {
64         LayerCreationArgs args(std::make_optional(id));
65         args.name = "testlayer";
66         args.addToRoot = true;
67         args.layerStackToMirror = layerStackToMirror;
68         return args;
69     }
70 
getTraversalPath(const LayerHierarchy & hierarchy)71     std::vector<uint32_t> getTraversalPath(const LayerHierarchy& hierarchy) const {
72         std::vector<uint32_t> layerIds;
73         hierarchy.traverse([&layerIds = layerIds](const LayerHierarchy& hierarchy,
74                                                   const LayerHierarchy::TraversalPath&) -> bool {
75             layerIds.emplace_back(hierarchy.getLayer()->id);
76             return true;
77         });
78         return layerIds;
79     }
80 
getTraversalPathInZOrder(const LayerHierarchy & hierarchy)81     std::vector<uint32_t> getTraversalPathInZOrder(const LayerHierarchy& hierarchy) const {
82         std::vector<uint32_t> layerIds;
83         hierarchy.traverseInZOrder(
84                 [&layerIds = layerIds](const LayerHierarchy& hierarchy,
85                                        const LayerHierarchy::TraversalPath&) -> bool {
86                     layerIds.emplace_back(hierarchy.getLayer()->id);
87                     return true;
88                 });
89         return layerIds;
90     }
91 
createRootLayer(uint32_t id)92     virtual void createRootLayer(uint32_t id) {
93         std::vector<std::unique_ptr<RequestedLayerState>> layers;
94         layers.emplace_back(std::make_unique<RequestedLayerState>(
95                 createArgs(/*id=*/id, /*canBeRoot=*/true, /*parent=*/UNASSIGNED_LAYER_ID,
96                            /*mirror=*/UNASSIGNED_LAYER_ID)));
97         mLifecycleManager.addLayers(std::move(layers));
98     }
99 
createDisplayMirrorLayer(uint32_t id,ui::LayerStack layerStack)100     void createDisplayMirrorLayer(uint32_t id, ui::LayerStack layerStack) {
101         std::vector<std::unique_ptr<RequestedLayerState>> layers;
102         layers.emplace_back(std::make_unique<RequestedLayerState>(
103                 createDisplayMirrorArgs(/*id=*/id, layerStack)));
104         mLifecycleManager.addLayers(std::move(layers));
105     }
106 
createLayer(uint32_t id,uint32_t parentId)107     virtual void createLayer(uint32_t id, uint32_t parentId) {
108         std::vector<std::unique_ptr<RequestedLayerState>> layers;
109         layers.emplace_back(std::make_unique<RequestedLayerState>(
110                 createArgs(/*id=*/id, /*canBeRoot=*/false, /*parent=*/parentId,
111                            /*mirror=*/UNASSIGNED_LAYER_ID)));
112         mLifecycleManager.addLayers(std::move(layers));
113     }
114 
reparentLayerTransaction(uint32_t id,uint32_t newParentId)115     std::vector<TransactionState> reparentLayerTransaction(uint32_t id, uint32_t newParentId) {
116         std::vector<TransactionState> transactions;
117         transactions.emplace_back();
118         transactions.back().states.push_back({});
119         transactions.back().states.front().parentId = newParentId;
120         transactions.back().states.front().state.what = layer_state_t::eReparent;
121         transactions.back().states.front().relativeParentId = UNASSIGNED_LAYER_ID;
122         transactions.back().states.front().layerId = id;
123         return transactions;
124     }
125 
reparentLayer(uint32_t id,uint32_t newParentId)126     void reparentLayer(uint32_t id, uint32_t newParentId) {
127         mLifecycleManager.applyTransactions(reparentLayerTransaction(id, newParentId));
128     }
129 
relativeLayerTransaction(uint32_t id,uint32_t relativeParentId)130     std::vector<TransactionState> relativeLayerTransaction(uint32_t id, uint32_t relativeParentId) {
131         std::vector<TransactionState> transactions;
132         transactions.emplace_back();
133         transactions.back().states.push_back({});
134         transactions.back().states.front().relativeParentId = relativeParentId;
135         transactions.back().states.front().state.what = layer_state_t::eRelativeLayerChanged;
136         transactions.back().states.front().layerId = id;
137         return transactions;
138     }
139 
reparentRelativeLayer(uint32_t id,uint32_t relativeParentId)140     void reparentRelativeLayer(uint32_t id, uint32_t relativeParentId) {
141         mLifecycleManager.applyTransactions(relativeLayerTransaction(id, relativeParentId));
142     }
143 
removeRelativeZ(uint32_t id)144     void removeRelativeZ(uint32_t id) {
145         std::vector<TransactionState> transactions;
146         transactions.emplace_back();
147         transactions.back().states.push_back({});
148         transactions.back().states.front().state.what = layer_state_t::eLayerChanged;
149         transactions.back().states.front().layerId = id;
150         mLifecycleManager.applyTransactions(transactions);
151     }
152 
mirrorLayer(uint32_t id,uint32_t parentId,uint32_t layerIdToMirror)153     virtual void mirrorLayer(uint32_t id, uint32_t parentId, uint32_t layerIdToMirror) {
154         std::vector<std::unique_ptr<RequestedLayerState>> layers;
155         layers.emplace_back(std::make_unique<RequestedLayerState>(
156                 createArgs(/*id=*/id, /*canBeRoot=*/false, /*parent=*/parentId,
157                            /*mirror=*/layerIdToMirror)));
158         mLifecycleManager.addLayers(std::move(layers));
159     }
160 
updateBackgroundColor(uint32_t id,half alpha)161     void updateBackgroundColor(uint32_t id, half alpha) {
162         std::vector<TransactionState> transactions;
163         transactions.emplace_back();
164         transactions.back().states.push_back({});
165         transactions.back().states.front().state.what = layer_state_t::eBackgroundColorChanged;
166         transactions.back().states.front().state.bgColor.a = alpha;
167         transactions.back().states.front().layerId = id;
168         mLifecycleManager.applyTransactions(transactions);
169     }
170 
destroyLayerHandle(uint32_t id)171     void destroyLayerHandle(uint32_t id) { mLifecycleManager.onHandlesDestroyed({id}); }
172 
updateAndVerify(LayerHierarchyBuilder & hierarchyBuilder)173     void updateAndVerify(LayerHierarchyBuilder& hierarchyBuilder) {
174         if (mLifecycleManager.getGlobalChanges().test(RequestedLayerState::Changes::Hierarchy)) {
175             hierarchyBuilder.update(mLifecycleManager.getLayers(),
176                                     mLifecycleManager.getDestroyedLayers());
177         }
178         mLifecycleManager.commitChanges();
179 
180         // rebuild layer hierarchy from scratch and verify that it matches the updated state.
181         LayerHierarchyBuilder newBuilder(mLifecycleManager.getLayers());
182         EXPECT_EQ(getTraversalPath(hierarchyBuilder.getHierarchy()),
183                   getTraversalPath(newBuilder.getHierarchy()));
184         EXPECT_EQ(getTraversalPathInZOrder(hierarchyBuilder.getHierarchy()),
185                   getTraversalPathInZOrder(newBuilder.getHierarchy()));
186         EXPECT_FALSE(
187                 mLifecycleManager.getGlobalChanges().test(RequestedLayerState::Changes::Hierarchy));
188     }
189 
setZTransaction(uint32_t id,int32_t z)190     std::vector<TransactionState> setZTransaction(uint32_t id, int32_t z) {
191         std::vector<TransactionState> transactions;
192         transactions.emplace_back();
193         transactions.back().states.push_back({});
194 
195         transactions.back().states.front().state.what = layer_state_t::eLayerChanged;
196         transactions.back().states.front().layerId = id;
197         transactions.back().states.front().state.z = z;
198         return transactions;
199     }
200 
setZ(uint32_t id,int32_t z)201     void setZ(uint32_t id, int32_t z) {
202         mLifecycleManager.applyTransactions(setZTransaction(id, z));
203     }
204 
setCrop(uint32_t id,const Rect & crop)205     void setCrop(uint32_t id, const Rect& crop) {
206         std::vector<TransactionState> transactions;
207         transactions.emplace_back();
208         transactions.back().states.push_back({});
209 
210         transactions.back().states.front().state.what = layer_state_t::eCropChanged;
211         transactions.back().states.front().layerId = id;
212         transactions.back().states.front().state.crop = crop;
213         mLifecycleManager.applyTransactions(transactions);
214     }
215 
setFlags(uint32_t id,uint32_t mask,uint32_t flags)216     void setFlags(uint32_t id, uint32_t mask, uint32_t flags) {
217         std::vector<TransactionState> transactions;
218         transactions.emplace_back();
219         transactions.back().states.push_back({});
220 
221         transactions.back().states.front().state.what = layer_state_t::eFlagsChanged;
222         transactions.back().states.front().state.flags = flags;
223         transactions.back().states.front().state.mask = mask;
224         transactions.back().states.front().layerId = id;
225         mLifecycleManager.applyTransactions(transactions);
226     }
227 
setAlpha(uint32_t id,float alpha)228     void setAlpha(uint32_t id, float alpha) {
229         std::vector<TransactionState> transactions;
230         transactions.emplace_back();
231         transactions.back().states.push_back({});
232 
233         transactions.back().states.front().state.what = layer_state_t::eAlphaChanged;
234         transactions.back().states.front().layerId = id;
235         transactions.back().states.front().state.color.a = static_cast<half>(alpha);
236         mLifecycleManager.applyTransactions(transactions);
237     }
238 
hideLayer(uint32_t id)239     void hideLayer(uint32_t id) {
240         setFlags(id, layer_state_t::eLayerHidden, layer_state_t::eLayerHidden);
241     }
242 
showLayer(uint32_t id)243     void showLayer(uint32_t id) { setFlags(id, layer_state_t::eLayerHidden, 0); }
244 
245     void setColor(uint32_t id, half3 rgb = half3(1._hf, 1._hf, 1._hf)) {
246         std::vector<TransactionState> transactions;
247         transactions.emplace_back();
248         transactions.back().states.push_back({});
249         transactions.back().states.front().state.what = layer_state_t::eColorChanged;
250         transactions.back().states.front().state.color.rgb = rgb;
251         transactions.back().states.front().layerId = id;
252         mLifecycleManager.applyTransactions(transactions);
253     }
254 
setLayerStack(uint32_t id,int32_t layerStack)255     void setLayerStack(uint32_t id, int32_t layerStack) {
256         std::vector<TransactionState> transactions;
257         transactions.emplace_back();
258         transactions.back().states.push_back({});
259 
260         transactions.back().states.front().state.what = layer_state_t::eLayerStackChanged;
261         transactions.back().states.front().layerId = id;
262         transactions.back().states.front().state.layerStack = ui::LayerStack::fromValue(layerStack);
263         mLifecycleManager.applyTransactions(transactions);
264     }
265 
setTouchableRegion(uint32_t id,Region region)266     void setTouchableRegion(uint32_t id, Region region) {
267         std::vector<TransactionState> transactions;
268         transactions.emplace_back();
269         transactions.back().states.push_back({});
270 
271         transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
272         transactions.back().states.front().layerId = id;
273         transactions.back().states.front().state.windowInfoHandle =
274                 sp<gui::WindowInfoHandle>::make();
275         auto inputInfo = transactions.back().states.front().state.windowInfoHandle->editInfo();
276         inputInfo->touchableRegion = region;
277         inputInfo->token = sp<BBinder>::make();
278         mLifecycleManager.applyTransactions(transactions);
279     }
280 
setTouchableRegionCrop(uint32_t id,Region region,uint32_t touchCropId,bool replaceTouchableRegionWithCrop)281     void setTouchableRegionCrop(uint32_t id, Region region, uint32_t touchCropId,
282                                 bool replaceTouchableRegionWithCrop) {
283         std::vector<TransactionState> transactions;
284         transactions.emplace_back();
285         transactions.back().states.push_back({});
286 
287         transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
288         transactions.back().states.front().layerId = id;
289         transactions.back().states.front().state.windowInfoHandle =
290                 sp<gui::WindowInfoHandle>::make();
291         auto inputInfo = transactions.back().states.front().state.windowInfoHandle->editInfo();
292         inputInfo->touchableRegion = region;
293         inputInfo->replaceTouchableRegionWithCrop = replaceTouchableRegionWithCrop;
294         transactions.back().states.front().touchCropId = touchCropId;
295 
296         inputInfo->token = sp<BBinder>::make();
297         mLifecycleManager.applyTransactions(transactions);
298     }
299 
setBackgroundBlurRadius(uint32_t id,uint32_t backgroundBlurRadius)300     void setBackgroundBlurRadius(uint32_t id, uint32_t backgroundBlurRadius) {
301         std::vector<TransactionState> transactions;
302         transactions.emplace_back();
303         transactions.back().states.push_back({});
304 
305         transactions.back().states.front().state.what = layer_state_t::eBackgroundBlurRadiusChanged;
306         transactions.back().states.front().layerId = id;
307         transactions.back().states.front().state.backgroundBlurRadius = backgroundBlurRadius;
308         mLifecycleManager.applyTransactions(transactions);
309     }
310 
311     LayerLifecycleManager mLifecycleManager;
312 };
313 
314 } // namespace android::surfaceflinger::frontend
315