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 "QueuedTransactionState.h" 20 #include "RequestedLayerState.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<QueuedTransactionState>&, 47 bool ignoreUnknownLayers = false); 48 // Ignore unknown handles when iteroping with legacy front end. In the old world, we 49 // would create child layers which are not necessary with the new front end. This means 50 // we will get notified for handle changes that don't exist in the new front end. 51 void onHandlesDestroyed(const std::vector<std::pair<uint32_t, std::string /* debugName */>>&, 52 bool ignoreUnknownHandles = false); 53 54 // Detaches the layer from its relative parent to prevent a loop in the 55 // layer hierarchy. This overrides the RequestedLayerState and leaves 56 // the system in an invalid state. This is always a client error that 57 // needs to be fixed but overriding the state allows us to fail gracefully. 58 void fixRelativeZLoop(uint32_t relativeRootId); 59 60 // Destroys RequestedLayerStates that are marked to be destroyed. Invokes all 61 // ILifecycleListener callbacks and clears any change flags from previous state 62 // updates. This function should be called outside the hot path since it's not 63 // critical to composition. 64 void commitChanges(); 65 66 class ILifecycleListener { 67 public: 68 virtual ~ILifecycleListener() = default; 69 // Called on commitChanges when a layer is added. The callback includes 70 // the layer state the client was created with as well as any state updates 71 // until changes were committed. 72 virtual void onLayerAdded(const RequestedLayerState&) = 0; 73 // Called on commitChanges when a layer has been destroyed. The callback 74 // includes the final state before the layer was destroyed. 75 virtual void onLayerDestroyed(const RequestedLayerState&) = 0; 76 }; 77 void addLifecycleListener(std::shared_ptr<ILifecycleListener>); 78 void removeLifecycleListener(std::shared_ptr<ILifecycleListener>); 79 const std::vector<std::unique_ptr<RequestedLayerState>>& getLayers() const; 80 const std::vector<std::unique_ptr<RequestedLayerState>>& getDestroyedLayers() const; 81 const std::vector<RequestedLayerState*>& getChangedLayers() const; 82 const ftl::Flags<RequestedLayerState::Changes> getGlobalChanges() const; 83 const RequestedLayerState* getLayerFromId(uint32_t) const; 84 bool isLayerSecure(uint32_t) const; 85 86 private: 87 friend class LayerLifecycleManagerTest; 88 friend class HierarchyBuilderTest; 89 friend class android::SurfaceFlinger; 90 91 RequestedLayerState* getLayerFromId(uint32_t); 92 std::vector<uint32_t>* getLinkedLayersFromId(uint32_t); 93 uint32_t linkLayer(uint32_t layerId, uint32_t layerToLink); 94 uint32_t unlinkLayer(uint32_t layerId, uint32_t linkedLayer); 95 std::vector<uint32_t> unlinkLayers(const std::vector<uint32_t>& layerIds, uint32_t linkedLayer); 96 97 void updateDisplayMirrorLayers(RequestedLayerState& rootLayer); 98 99 struct References { 100 // Lifetime tied to mLayers 101 RequestedLayerState& owner; 102 std::vector<uint32_t> references; 103 std::string getDebugString() const; 104 }; 105 std::unordered_map<uint32_t, References> mIdToLayer; 106 // Listeners are invoked once changes are committed. 107 std::vector<std::shared_ptr<ILifecycleListener>> mListeners; 108 // Layers that mirror a display stack (see updateDisplayMirrorLayers) 109 std::vector<uint32_t> mDisplayMirroringLayers; 110 111 // Aggregation of changes since last commit. 112 ftl::Flags<RequestedLayerState::Changes> mGlobalChanges; 113 std::vector<std::unique_ptr<RequestedLayerState>> mLayers; 114 // Layers pending destruction. Layers will be destroyed once changes are committed. 115 std::vector<std::unique_ptr<RequestedLayerState>> mDestroyedLayers; 116 // Keeps track of all the layers that were added in order. Changes will be cleared once 117 // committed. 118 std::vector<RequestedLayerState*> mAddedLayers; 119 // Keeps track of new and layers with states changes since last commit. 120 std::vector<RequestedLayerState*> mChangedLayers; 121 }; 122 123 } // namespace android::surfaceflinger::frontend 124