xref: /aosp_15_r20/frameworks/native/services/surfaceflinger/tests/common/LayerLifecycleManagerHelper.h (revision 38e8c45f13ce32b0dcecb25141ffecaf386fa17f) 
1 /*
2  * Copyright 2024 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 
19 #include <gui/fake/BufferData.h>
20 #include <renderengine/mock/FakeExternalTexture.h>
21 #include <ui/ShadowSettings.h>
22 
23 #include <Client.h> // temporarily needed for LayerCreationArgs
24 #include <FrontEnd/LayerCreationArgs.h>
25 #include <FrontEnd/LayerHierarchy.h>
26 #include <FrontEnd/LayerLifecycleManager.h>
27 #include <FrontEnd/LayerSnapshotBuilder.h>
28 #include <Layer.h> // needed for framerate
29 
30 namespace android::surfaceflinger::frontend {
31 
32 class LayerLifecycleManagerHelper {
33 public:
LayerLifecycleManagerHelper(LayerLifecycleManager & layerLifecycleManager)34     LayerLifecycleManagerHelper(LayerLifecycleManager& layerLifecycleManager)
35           : mLifecycleManager(layerLifecycleManager) {}
36     ~LayerLifecycleManagerHelper() = default;
37 
createArgs(uint32_t id,bool canBeRoot,uint32_t parentId,uint32_t layerIdToMirror)38     static LayerCreationArgs createArgs(uint32_t id, bool canBeRoot, uint32_t parentId,
39                                         uint32_t layerIdToMirror) {
40         LayerCreationArgs args(std::make_optional(id));
41         args.name = "testlayer";
42         args.addToRoot = canBeRoot;
43         args.parentId = parentId;
44         args.layerIdToMirror = layerIdToMirror;
45         return args;
46     }
47 
createDisplayMirrorArgs(uint32_t id,ui::LayerStack layerStackToMirror)48     static LayerCreationArgs createDisplayMirrorArgs(uint32_t id,
49                                                      ui::LayerStack layerStackToMirror) {
50         LayerCreationArgs args(std::make_optional(id));
51         args.name = "testlayer";
52         args.addToRoot = true;
53         args.layerStackToMirror = layerStackToMirror;
54         return args;
55     }
56 
rootLayer(uint32_t id)57     static std::unique_ptr<RequestedLayerState> rootLayer(uint32_t id) {
58         return std::make_unique<RequestedLayerState>(createArgs(/*id=*/id, /*canBeRoot=*/true,
59                                                                 /*parent=*/UNASSIGNED_LAYER_ID,
60                                                                 /*mirror=*/UNASSIGNED_LAYER_ID));
61     }
62 
childLayer(uint32_t id,uint32_t parentId)63     static std::unique_ptr<RequestedLayerState> childLayer(uint32_t id, uint32_t parentId) {
64         return std::make_unique<RequestedLayerState>(createArgs(/*id=*/id, /*canBeRoot=*/false,
65                                                                 parentId,
66                                                                 /*mirror=*/UNASSIGNED_LAYER_ID));
67     }
68 
setZTransaction(uint32_t id,int32_t z)69     static std::vector<TransactionState> setZTransaction(uint32_t id, int32_t z) {
70         std::vector<TransactionState> transactions;
71         transactions.emplace_back();
72         transactions.back().states.push_back({});
73 
74         transactions.back().states.front().state.what = layer_state_t::eLayerChanged;
75         transactions.back().states.front().layerId = id;
76         transactions.back().states.front().state.z = z;
77         return transactions;
78     }
79 
createRootLayer(uint32_t id)80     void createRootLayer(uint32_t id) {
81         std::vector<std::unique_ptr<RequestedLayerState>> layers;
82         layers.emplace_back(std::make_unique<RequestedLayerState>(
83                 createArgs(/*id=*/id, /*canBeRoot=*/true, /*parent=*/UNASSIGNED_LAYER_ID,
84                            /*mirror=*/UNASSIGNED_LAYER_ID)));
85         mLifecycleManager.addLayers(std::move(layers));
86     }
87 
createRootLayerWithUid(uint32_t id,gui::Uid uid)88     void createRootLayerWithUid(uint32_t id, gui::Uid uid) {
89         std::vector<std::unique_ptr<RequestedLayerState>> layers;
90         auto args = createArgs(/*id=*/id, /*canBeRoot=*/true, /*parent=*/UNASSIGNED_LAYER_ID,
91                                /*mirror=*/UNASSIGNED_LAYER_ID);
92         args.ownerUid = uid.val();
93         layers.emplace_back(std::make_unique<RequestedLayerState>(args));
94         mLifecycleManager.addLayers(std::move(layers));
95     }
96 
createDisplayMirrorLayer(uint32_t id,ui::LayerStack layerStack)97     void createDisplayMirrorLayer(uint32_t id, ui::LayerStack layerStack) {
98         std::vector<std::unique_ptr<RequestedLayerState>> layers;
99         layers.emplace_back(std::make_unique<RequestedLayerState>(
100                 createDisplayMirrorArgs(/*id=*/id, layerStack)));
101         mLifecycleManager.addLayers(std::move(layers));
102     }
103 
createLayer(uint32_t id,uint32_t parentId)104     void createLayer(uint32_t id, uint32_t parentId) {
105         std::vector<std::unique_ptr<RequestedLayerState>> layers;
106         layers.emplace_back(std::make_unique<RequestedLayerState>(
107                 createArgs(/*id=*/id, /*canBeRoot=*/false, /*parent=*/parentId,
108                            /*mirror=*/UNASSIGNED_LAYER_ID)));
109         mLifecycleManager.addLayers(std::move(layers));
110     }
111 
reparentLayerTransaction(uint32_t id,uint32_t newParentId)112     std::vector<TransactionState> reparentLayerTransaction(uint32_t id, uint32_t newParentId) {
113         std::vector<TransactionState> transactions;
114         transactions.emplace_back();
115         transactions.back().states.push_back({});
116         transactions.back().states.front().parentId = newParentId;
117         transactions.back().states.front().state.what = layer_state_t::eReparent;
118         transactions.back().states.front().relativeParentId = UNASSIGNED_LAYER_ID;
119         transactions.back().states.front().layerId = id;
120         return transactions;
121     }
122 
reparentLayer(uint32_t id,uint32_t newParentId)123     void reparentLayer(uint32_t id, uint32_t newParentId) {
124         mLifecycleManager.applyTransactions(reparentLayerTransaction(id, newParentId));
125     }
126 
relativeLayerTransaction(uint32_t id,uint32_t relativeParentId)127     std::vector<TransactionState> relativeLayerTransaction(uint32_t id, uint32_t relativeParentId) {
128         std::vector<TransactionState> transactions;
129         transactions.emplace_back();
130         transactions.back().states.push_back({});
131         transactions.back().states.front().relativeParentId = relativeParentId;
132         transactions.back().states.front().state.what = layer_state_t::eRelativeLayerChanged;
133         transactions.back().states.front().layerId = id;
134         return transactions;
135     }
136 
reparentRelativeLayer(uint32_t id,uint32_t relativeParentId)137     void reparentRelativeLayer(uint32_t id, uint32_t relativeParentId) {
138         mLifecycleManager.applyTransactions(relativeLayerTransaction(id, relativeParentId));
139     }
140 
removeRelativeZ(uint32_t id)141     void removeRelativeZ(uint32_t id) {
142         std::vector<TransactionState> transactions;
143         transactions.emplace_back();
144         transactions.back().states.push_back({});
145         transactions.back().states.front().state.what = layer_state_t::eLayerChanged;
146         transactions.back().states.front().layerId = id;
147         mLifecycleManager.applyTransactions(transactions);
148     }
149 
setPosition(uint32_t id,float x,float y)150     void setPosition(uint32_t id, float x, float y) {
151         std::vector<TransactionState> transactions;
152         transactions.emplace_back();
153         transactions.back().states.push_back({});
154         transactions.back().states.front().state.what = layer_state_t::ePositionChanged;
155         transactions.back().states.front().state.x = x;
156         transactions.back().states.front().state.y = y;
157         transactions.back().states.front().layerId = id;
158         mLifecycleManager.applyTransactions(transactions);
159     }
160 
mirrorLayer(uint32_t id,uint32_t parentId,uint32_t layerIdToMirror)161     void mirrorLayer(uint32_t id, uint32_t parentId, uint32_t layerIdToMirror) {
162         std::vector<std::unique_ptr<RequestedLayerState>> layers;
163         layers.emplace_back(std::make_unique<RequestedLayerState>(
164                 createArgs(/*id=*/id, /*canBeRoot=*/false, /*parent=*/parentId,
165                            /*mirror=*/layerIdToMirror)));
166         mLifecycleManager.addLayers(std::move(layers));
167     }
168 
updateBackgroundColor(uint32_t id,half alpha)169     void updateBackgroundColor(uint32_t id, half alpha) {
170         std::vector<TransactionState> transactions;
171         transactions.emplace_back();
172         transactions.back().states.push_back({});
173         transactions.back().states.front().state.what = layer_state_t::eBackgroundColorChanged;
174         transactions.back().states.front().state.bgColor.a = alpha;
175         transactions.back().states.front().layerId = id;
176         mLifecycleManager.applyTransactions(transactions);
177     }
178 
destroyLayerHandle(uint32_t id)179     void destroyLayerHandle(uint32_t id) { mLifecycleManager.onHandlesDestroyed({{id, "test"}}); }
180 
setZ(uint32_t id,int32_t z)181     void setZ(uint32_t id, int32_t z) {
182         mLifecycleManager.applyTransactions(setZTransaction(id, z));
183     }
184 
setCrop(uint32_t id,const FloatRect & crop)185     void setCrop(uint32_t id, const FloatRect& crop) {
186         std::vector<TransactionState> transactions;
187         transactions.emplace_back();
188         transactions.back().states.push_back({});
189 
190         transactions.back().states.front().state.what = layer_state_t::eCropChanged;
191         transactions.back().states.front().layerId = id;
192         transactions.back().states.front().state.crop = crop;
193         mLifecycleManager.applyTransactions(transactions);
194     }
195 
setCrop(uint32_t id,const Rect & crop)196     void setCrop(uint32_t id, const Rect& crop) { setCrop(id, crop.toFloatRect()); }
197 
setFlags(uint32_t id,uint32_t mask,uint32_t flags)198     void setFlags(uint32_t id, uint32_t mask, uint32_t flags) {
199         std::vector<TransactionState> transactions;
200         transactions.emplace_back();
201         transactions.back().states.push_back({});
202 
203         transactions.back().states.front().state.what = layer_state_t::eFlagsChanged;
204         transactions.back().states.front().state.flags = flags;
205         transactions.back().states.front().state.mask = mask;
206         transactions.back().states.front().layerId = id;
207         mLifecycleManager.applyTransactions(transactions);
208     }
209 
setAlpha(uint32_t id,float alpha)210     void setAlpha(uint32_t id, float alpha) {
211         std::vector<TransactionState> transactions;
212         transactions.emplace_back();
213         transactions.back().states.push_back({});
214 
215         transactions.back().states.front().state.what = layer_state_t::eAlphaChanged;
216         transactions.back().states.front().layerId = id;
217         transactions.back().states.front().state.color.a = static_cast<half>(alpha);
218         mLifecycleManager.applyTransactions(transactions);
219     }
220 
setAutoRefresh(uint32_t id,bool autoRefresh)221     void setAutoRefresh(uint32_t id, bool autoRefresh) {
222         std::vector<TransactionState> transactions;
223         transactions.emplace_back();
224         transactions.back().states.push_back({});
225 
226         transactions.back().states.front().state.what = layer_state_t::eAutoRefreshChanged;
227         transactions.back().states.front().layerId = id;
228         transactions.back().states.front().state.autoRefresh = autoRefresh;
229         mLifecycleManager.applyTransactions(transactions);
230     }
231 
hideLayer(uint32_t id)232     void hideLayer(uint32_t id) {
233         setFlags(id, layer_state_t::eLayerHidden, layer_state_t::eLayerHidden);
234     }
235 
showLayer(uint32_t id)236     void showLayer(uint32_t id) { setFlags(id, layer_state_t::eLayerHidden, 0); }
237 
238     void setColor(uint32_t id, half3 rgb = half3(1._hf, 1._hf, 1._hf)) {
239         std::vector<TransactionState> transactions;
240         transactions.emplace_back();
241         transactions.back().states.push_back({});
242         transactions.back().states.front().state.what = layer_state_t::eColorChanged;
243         transactions.back().states.front().state.color.rgb = rgb;
244         transactions.back().states.front().layerId = id;
245         mLifecycleManager.applyTransactions(transactions);
246     }
247 
setLayerStack(uint32_t id,int32_t layerStack)248     void setLayerStack(uint32_t id, int32_t layerStack) {
249         std::vector<TransactionState> transactions;
250         transactions.emplace_back();
251         transactions.back().states.push_back({});
252 
253         transactions.back().states.front().state.what = layer_state_t::eLayerStackChanged;
254         transactions.back().states.front().layerId = id;
255         transactions.back().states.front().state.layerStack = ui::LayerStack::fromValue(layerStack);
256         mLifecycleManager.applyTransactions(transactions);
257     }
258 
setTouchableRegion(uint32_t id,Region region)259     void setTouchableRegion(uint32_t id, Region region) {
260         std::vector<TransactionState> transactions;
261         transactions.emplace_back();
262         transactions.back().states.push_back({});
263 
264         transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
265         transactions.back().states.front().layerId = id;
266         transactions.back().states.front().state.windowInfoHandle =
267                 sp<gui::WindowInfoHandle>::make();
268         auto inputInfo = transactions.back().states.front().state.windowInfoHandle->editInfo();
269         inputInfo->touchableRegion = region;
270         inputInfo->token = sp<BBinder>::make();
271         mLifecycleManager.applyTransactions(transactions);
272     }
273 
setInputInfo(uint32_t id,std::function<void (gui::WindowInfo &)> configureInput)274     void setInputInfo(uint32_t id, std::function<void(gui::WindowInfo&)> configureInput) {
275         std::vector<TransactionState> transactions;
276         transactions.emplace_back();
277         transactions.back().states.push_back({});
278 
279         transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
280         transactions.back().states.front().layerId = id;
281         transactions.back().states.front().state.windowInfoHandle =
282                 sp<gui::WindowInfoHandle>::make();
283         auto inputInfo = transactions.back().states.front().state.windowInfoHandle->editInfo();
284         if (!inputInfo->token) {
285             inputInfo->token = sp<BBinder>::make();
286         }
287         configureInput(*inputInfo);
288 
289         mLifecycleManager.applyTransactions(transactions);
290     }
291 
setTouchableRegionCrop(uint32_t id,Region region,uint32_t touchCropId,bool replaceTouchableRegionWithCrop)292     void setTouchableRegionCrop(uint32_t id, Region region, uint32_t touchCropId,
293                                 bool replaceTouchableRegionWithCrop) {
294         std::vector<TransactionState> transactions;
295         transactions.emplace_back();
296         transactions.back().states.push_back({});
297 
298         transactions.back().states.front().state.what = layer_state_t::eInputInfoChanged;
299         transactions.back().states.front().layerId = id;
300         transactions.back().states.front().state.windowInfoHandle =
301                 sp<gui::WindowInfoHandle>::make();
302         auto inputInfo = transactions.back().states.front().state.windowInfoHandle->editInfo();
303         inputInfo->touchableRegion = region;
304         inputInfo->replaceTouchableRegionWithCrop = replaceTouchableRegionWithCrop;
305         transactions.back().states.front().touchCropId = touchCropId;
306 
307         inputInfo->token = sp<BBinder>::make();
308         mLifecycleManager.applyTransactions(transactions);
309     }
310 
setBackgroundBlurRadius(uint32_t id,uint32_t backgroundBlurRadius)311     void setBackgroundBlurRadius(uint32_t id, uint32_t backgroundBlurRadius) {
312         std::vector<TransactionState> transactions;
313         transactions.emplace_back();
314         transactions.back().states.push_back({});
315 
316         transactions.back().states.front().state.what = layer_state_t::eBackgroundBlurRadiusChanged;
317         transactions.back().states.front().layerId = id;
318         transactions.back().states.front().state.backgroundBlurRadius = backgroundBlurRadius;
319         mLifecycleManager.applyTransactions(transactions);
320     }
321 
setFrameRateSelectionPriority(uint32_t id,int32_t priority)322     void setFrameRateSelectionPriority(uint32_t id, int32_t priority) {
323         std::vector<TransactionState> transactions;
324         transactions.emplace_back();
325         transactions.back().states.push_back({});
326 
327         transactions.back().states.front().state.what = layer_state_t::eFrameRateSelectionPriority;
328         transactions.back().states.front().layerId = id;
329         transactions.back().states.front().state.frameRateSelectionPriority = priority;
330         mLifecycleManager.applyTransactions(transactions);
331     }
332 
setFrameRate(uint32_t id,float frameRate,int8_t compatibility,int8_t changeFrameRateStrategy)333     void setFrameRate(uint32_t id, float frameRate, int8_t compatibility,
334                       int8_t changeFrameRateStrategy) {
335         std::vector<TransactionState> transactions;
336         transactions.emplace_back();
337         transactions.back().states.push_back({});
338 
339         transactions.back().states.front().state.what = layer_state_t::eFrameRateChanged;
340         transactions.back().states.front().layerId = id;
341         transactions.back().states.front().state.frameRate = frameRate;
342         transactions.back().states.front().state.frameRateCompatibility = compatibility;
343         transactions.back().states.front().state.changeFrameRateStrategy = changeFrameRateStrategy;
344         mLifecycleManager.applyTransactions(transactions);
345     }
346 
setFrameRate(uint32_t id,Layer::FrameRate framerate)347     void setFrameRate(uint32_t id, Layer::FrameRate framerate) {
348         std::vector<TransactionState> transactions;
349         transactions.emplace_back();
350         transactions.back().states.push_back({});
351 
352         transactions.back().states.front().state.what = layer_state_t::eFrameRateChanged;
353         transactions.back().states.front().layerId = id;
354         transactions.back().states.front().state.frameRate = framerate.vote.rate.getValue();
355         transactions.back().states.front().state.frameRateCompatibility = 0;
356         transactions.back().states.front().state.changeFrameRateStrategy = 0;
357         mLifecycleManager.applyTransactions(transactions);
358     }
359 
setFrameRateCategory(uint32_t id,int8_t frameRateCategory)360     void setFrameRateCategory(uint32_t id, int8_t frameRateCategory) {
361         std::vector<TransactionState> transactions;
362         transactions.emplace_back();
363         transactions.back().states.push_back({});
364 
365         transactions.back().states.front().state.what = layer_state_t::eFrameRateCategoryChanged;
366         transactions.back().states.front().layerId = id;
367         transactions.back().states.front().state.frameRateCategory = frameRateCategory;
368         mLifecycleManager.applyTransactions(transactions);
369     }
370 
setFrameRateSelectionStrategy(uint32_t id,int8_t strategy)371     void setFrameRateSelectionStrategy(uint32_t id, int8_t strategy) {
372         std::vector<TransactionState> transactions;
373         transactions.emplace_back();
374         transactions.back().states.push_back({});
375 
376         transactions.back().states.front().state.what =
377                 layer_state_t::eFrameRateSelectionStrategyChanged;
378         transactions.back().states.front().layerId = id;
379         transactions.back().states.front().state.frameRateSelectionStrategy = strategy;
380         mLifecycleManager.applyTransactions(transactions);
381     }
382 
setDefaultFrameRateCompatibility(uint32_t id,int8_t defaultFrameRateCompatibility)383     void setDefaultFrameRateCompatibility(uint32_t id, int8_t defaultFrameRateCompatibility) {
384         std::vector<TransactionState> transactions;
385         transactions.emplace_back();
386         transactions.back().states.push_back({});
387 
388         transactions.back().states.front().state.what =
389                 layer_state_t::eDefaultFrameRateCompatibilityChanged;
390         transactions.back().states.front().layerId = id;
391         transactions.back().states.front().state.defaultFrameRateCompatibility =
392                 defaultFrameRateCompatibility;
393         mLifecycleManager.applyTransactions(transactions);
394     }
395 
setRoundedCorners(uint32_t id,float radius)396     void setRoundedCorners(uint32_t id, float radius) {
397         std::vector<TransactionState> transactions;
398         transactions.emplace_back();
399         transactions.back().states.push_back({});
400 
401         transactions.back().states.front().state.what = layer_state_t::eCornerRadiusChanged;
402         transactions.back().states.front().layerId = id;
403         transactions.back().states.front().state.cornerRadius = radius;
404         mLifecycleManager.applyTransactions(transactions);
405     }
406 
setBuffer(uint32_t id,std::shared_ptr<renderengine::ExternalTexture> texture)407     void setBuffer(uint32_t id, std::shared_ptr<renderengine::ExternalTexture> texture) {
408         std::vector<TransactionState> transactions;
409         transactions.emplace_back();
410         transactions.back().states.push_back({});
411 
412         transactions.back().states.front().state.what = layer_state_t::eBufferChanged;
413         transactions.back().states.front().layerId = id;
414         transactions.back().states.front().externalTexture = texture;
415         transactions.back().states.front().state.bufferData =
416                 std::make_shared<fake::BufferData>(texture->getId(), texture->getWidth(),
417                                                    texture->getHeight(), texture->getPixelFormat(),
418                                                    texture->getUsage());
419         mLifecycleManager.applyTransactions(transactions);
420     }
421 
setBuffer(uint32_t id)422     void setBuffer(uint32_t id) {
423         static uint64_t sBufferId = 1;
424         setBuffer(id,
425                   std::make_shared<renderengine::mock::
426                                            FakeExternalTexture>(1U /*width*/, 1U /*height*/,
427                                                                 sBufferId++,
428                                                                 HAL_PIXEL_FORMAT_RGBA_8888,
429                                                                 GRALLOC_USAGE_PROTECTED /*usage*/));
430     }
431 
setFrontBuffer(uint32_t id)432     void setFrontBuffer(uint32_t id) {
433         static uint64_t sBufferId = 1;
434         setBuffer(id,
435                   std::make_shared<renderengine::mock::FakeExternalTexture>(
436                           1U /*width*/, 1U /*height*/, sBufferId++, HAL_PIXEL_FORMAT_RGBA_8888,
437                           GRALLOC_USAGE_PROTECTED | AHARDWAREBUFFER_USAGE_FRONT_BUFFER /*usage*/));
438     }
439 
setBufferCrop(uint32_t id,const Rect & bufferCrop)440     void setBufferCrop(uint32_t id, const Rect& bufferCrop) {
441         std::vector<TransactionState> transactions;
442         transactions.emplace_back();
443         transactions.back().states.push_back({});
444 
445         transactions.back().states.front().state.what = layer_state_t::eBufferCropChanged;
446         transactions.back().states.front().layerId = id;
447         transactions.back().states.front().state.bufferCrop = bufferCrop;
448         mLifecycleManager.applyTransactions(transactions);
449     }
450 
setDamageRegion(uint32_t id,const Region & damageRegion)451     void setDamageRegion(uint32_t id, const Region& damageRegion) {
452         std::vector<TransactionState> transactions;
453         transactions.emplace_back();
454         transactions.back().states.push_back({});
455 
456         transactions.back().states.front().state.what = layer_state_t::eSurfaceDamageRegionChanged;
457         transactions.back().states.front().layerId = id;
458         transactions.back().states.front().state.surfaceDamageRegion = damageRegion;
459         mLifecycleManager.applyTransactions(transactions);
460     }
461 
setDataspace(uint32_t id,ui::Dataspace dataspace)462     void setDataspace(uint32_t id, ui::Dataspace dataspace) {
463         std::vector<TransactionState> transactions;
464         transactions.emplace_back();
465         transactions.back().states.push_back({});
466 
467         transactions.back().states.front().state.what = layer_state_t::eDataspaceChanged;
468         transactions.back().states.front().layerId = id;
469         transactions.back().states.front().state.dataspace = dataspace;
470         mLifecycleManager.applyTransactions(transactions);
471     }
472 
setMatrix(uint32_t id,float dsdx,float dtdx,float dtdy,float dsdy)473     void setMatrix(uint32_t id, float dsdx, float dtdx, float dtdy, float dsdy) {
474         layer_state_t::matrix22_t matrix{dsdx, dtdx, dtdy, dsdy};
475 
476         std::vector<TransactionState> transactions;
477         transactions.emplace_back();
478         transactions.back().states.push_back({});
479 
480         transactions.back().states.front().state.what = layer_state_t::eMatrixChanged;
481         transactions.back().states.front().layerId = id;
482         transactions.back().states.front().state.matrix = matrix;
483         mLifecycleManager.applyTransactions(transactions);
484     }
485 
setShadowRadius(uint32_t id,float shadowRadius)486     void setShadowRadius(uint32_t id, float shadowRadius) {
487         std::vector<TransactionState> transactions;
488         transactions.emplace_back();
489         transactions.back().states.push_back({});
490 
491         transactions.back().states.front().state.what = layer_state_t::eShadowRadiusChanged;
492         transactions.back().states.front().layerId = id;
493         transactions.back().states.front().state.shadowRadius = shadowRadius;
494         mLifecycleManager.applyTransactions(transactions);
495     }
496 
setTrustedOverlay(uint32_t id,gui::TrustedOverlay trustedOverlay)497     void setTrustedOverlay(uint32_t id, gui::TrustedOverlay trustedOverlay) {
498         std::vector<TransactionState> transactions;
499         transactions.emplace_back();
500         transactions.back().states.push_back({});
501 
502         transactions.back().states.front().state.what = layer_state_t::eTrustedOverlayChanged;
503         transactions.back().states.front().layerId = id;
504         transactions.back().states.front().state.trustedOverlay = trustedOverlay;
505         mLifecycleManager.applyTransactions(transactions);
506     }
507 
setDropInputMode(uint32_t id,gui::DropInputMode dropInputMode)508     void setDropInputMode(uint32_t id, gui::DropInputMode dropInputMode) {
509         std::vector<TransactionState> transactions;
510         transactions.emplace_back();
511         transactions.back().states.push_back({});
512 
513         transactions.back().states.front().state.what = layer_state_t::eDropInputModeChanged;
514         transactions.back().states.front().layerId = id;
515         transactions.back().states.front().state.dropInputMode = dropInputMode;
516         mLifecycleManager.applyTransactions(transactions);
517     }
518 
setGameMode(uint32_t id,gui::GameMode gameMode)519     void setGameMode(uint32_t id, gui::GameMode gameMode) {
520         std::vector<TransactionState> transactions;
521         transactions.emplace_back();
522         transactions.back().states.push_back({});
523         transactions.back().states.front().state.what = layer_state_t::eMetadataChanged;
524         transactions.back().states.front().state.metadata = LayerMetadata();
525         transactions.back().states.front().state.metadata.setInt32(METADATA_GAME_MODE,
526                                                                    static_cast<int32_t>(gameMode));
527         transactions.back().states.front().layerId = id;
528         mLifecycleManager.applyTransactions(transactions);
529     }
530 
setEdgeExtensionEffect(uint32_t id,int edge)531     void setEdgeExtensionEffect(uint32_t id, int edge) {
532         std::vector<TransactionState> transactions;
533         transactions.emplace_back();
534         transactions.back().states.push_back({});
535 
536         transactions.back().states.front().layerId = id;
537         transactions.back().states.front().state.what |= layer_state_t::eEdgeExtensionChanged;
538         transactions.back().states.front().state.edgeExtensionParameters =
539                 gui::EdgeExtensionParameters();
540         transactions.back().states.front().state.edgeExtensionParameters.extendLeft = edge & LEFT;
541         transactions.back().states.front().state.edgeExtensionParameters.extendRight = edge & RIGHT;
542         transactions.back().states.front().state.edgeExtensionParameters.extendTop = edge & TOP;
543         transactions.back().states.front().state.edgeExtensionParameters.extendBottom =
544                 edge & BOTTOM;
545         mLifecycleManager.applyTransactions(transactions);
546     }
547 
548 private:
549     LayerLifecycleManager& mLifecycleManager;
550 };
551 
552 } // namespace android::surfaceflinger::frontend
553