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 #pragma once 18 19 #include "RequestedLayerState.h" 20 #include "TransactionState.h" 21 22 namespace android::surfaceflinger::frontend { 23 24 // Owns a collection of RequestedLayerStates and manages their lifecycle 25 // and state changes. 26 // 27 // RequestedLayerStates are tracked and destroyed if they have no parent and 28 // no handle left to keep them alive. The handle does not keep a reference to 29 // the RequestedLayerState but a layer id associated with the RequestedLayerState. 30 // If the handle is destroyed and the RequestedLayerState does not have a parent, 31 // the LayerLifecycleManager destroys the RequestedLayerState. 32 // 33 // Threading: This class is not thread safe, it requires external synchronization. 34 // 35 // Typical usage: Input states (new layers, transactions, destroyed layer handles) 36 // are collected in the background passed into the LayerLifecycleManager to update 37 // layer lifecycle and layer state at start of composition. 38 class LayerLifecycleManager { 39 public: 40 // External state changes should be updated in the following order: 41 void addLayers(std::vector<std::unique_ptr<RequestedLayerState>>); 42 // Ignore unknown layers when interoping with legacy front end. In legacy we destroy 43 // the layers it is unreachable. When using the LayerLifecycleManager for layer trace 44 // generation we may encounter layers which are known because we don't have an explicit 45 // lifecycle. Ignore these errors while we have to interop with legacy. 46 void applyTransactions(const std::vector<TransactionState>&, bool ignoreUnknownLayers = false); 47 // Ignore unknown handles when iteroping with legacy front end. In the old world, we 48 // would create child layers which are not necessary with the new front end. This means 49 // we will get notified for handle changes that don't exist in the new front end. 50 void onHandlesDestroyed(const std::vector<uint32_t>&, bool ignoreUnknownHandles = false); 51 52 // Detaches the layer from its relative parent to prevent a loop in the 53 // layer hierarchy. This overrides the RequestedLayerState and leaves 54 // the system in an invalid state. This is always a client error that 55 // needs to be fixed but overriding the state allows us to fail gracefully. 56 void fixRelativeZLoop(uint32_t relativeRootId); 57 58 // Destroys RequestedLayerStates that are marked to be destroyed. Invokes all 59 // ILifecycleListener callbacks and clears any change flags from previous state 60 // updates. This function should be called outside the hot path since it's not 61 // critical to composition. 62 void commitChanges(); 63 64 class ILifecycleListener { 65 public: 66 virtual ~ILifecycleListener() = default; 67 // Called on commitChanges when a layer is added. The callback includes 68 // the layer state the client was created with as well as any state updates 69 // until changes were committed. 70 virtual void onLayerAdded(const RequestedLayerState&) = 0; 71 // Called on commitChanges when a layer has been destroyed. The callback 72 // includes the final state before the layer was destroyed. 73 virtual void onLayerDestroyed(const RequestedLayerState&) = 0; 74 }; 75 void addLifecycleListener(std::shared_ptr<ILifecycleListener>); 76 void removeLifecycleListener(std::shared_ptr<ILifecycleListener>); 77 const std::vector<std::unique_ptr<RequestedLayerState>>& getLayers() const; 78 const std::vector<std::unique_ptr<RequestedLayerState>>& getDestroyedLayers() const; 79 const std::vector<RequestedLayerState*>& getChangedLayers() const; 80 const ftl::Flags<RequestedLayerState::Changes> getGlobalChanges() const; 81 const RequestedLayerState* getLayerFromId(uint32_t) const; 82 83 private: 84 friend class LayerLifecycleManagerTest; 85 friend class HierarchyBuilderTest; 86 friend class android::SurfaceFlinger; 87 88 RequestedLayerState* getLayerFromId(uint32_t); 89 std::vector<uint32_t>* getLinkedLayersFromId(uint32_t); 90 uint32_t linkLayer(uint32_t layerId, uint32_t layerToLink); 91 uint32_t unlinkLayer(uint32_t layerId, uint32_t linkedLayer); 92 std::vector<uint32_t> unlinkLayers(const std::vector<uint32_t>& layerIds, uint32_t linkedLayer); 93 94 void updateDisplayMirrorLayers(RequestedLayerState& rootLayer); 95 96 struct References { 97 // Lifetime tied to mLayers 98 RequestedLayerState& owner; 99 std::vector<uint32_t> references; 100 std::string getDebugString() const; 101 }; 102 std::unordered_map<uint32_t, References> mIdToLayer; 103 // Listeners are invoked once changes are committed. 104 std::vector<std::shared_ptr<ILifecycleListener>> mListeners; 105 // Layers that mirror a display stack (see updateDisplayMirrorLayers) 106 std::vector<uint32_t> mDisplayMirroringLayers; 107 108 // Aggregation of changes since last commit. 109 ftl::Flags<RequestedLayerState::Changes> mGlobalChanges; 110 std::vector<std::unique_ptr<RequestedLayerState>> mLayers; 111 // Layers pending destruction. Layers will be destroyed once changes are committed. 112 std::vector<std::unique_ptr<RequestedLayerState>> mDestroyedLayers; 113 // Keeps track of all the layers that were added in order. Changes will be cleared once 114 // committed. 115 std::vector<RequestedLayerState*> mAddedLayers; 116 // Keeps track of new and layers with states changes since last commit. 117 std::vector<RequestedLayerState*> mChangedLayers; 118 }; 119 120 } // namespace android::surfaceflinger::frontend 121