1 /* 2 * Copyright 2016 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 #ifndef ANDROID_SURFACEINTERCEPTOR_H 18 #define ANDROID_SURFACEINTERCEPTOR_H 19 20 #include <frameworks/native/cmds/surfacereplayer/proto/src/trace.pb.h> 21 22 #include <mutex> 23 24 #include <binder/IBinder.h> 25 26 #include <gui/LayerState.h> 27 28 #include <utils/KeyedVector.h> 29 #include <utils/SortedVector.h> 30 #include <utils/StrongPointer.h> 31 #include <utils/Vector.h> 32 33 #include "DisplayDevice.h" 34 35 namespace android { 36 37 class BufferItem; 38 class Layer; 39 class SurfaceFlinger; 40 struct ComposerState; 41 struct DisplayDeviceState; 42 struct DisplayState; 43 struct layer_state_t; 44 using Transaction = surfaceflinger::Transaction; 45 using Trace = surfaceflinger::Trace; 46 using Rectangle = surfaceflinger::Rectangle; 47 using SurfaceChange = surfaceflinger::SurfaceChange; 48 using Increment = surfaceflinger::Increment; 49 using DisplayChange = surfaceflinger::DisplayChange; 50 51 constexpr auto DEFAULT_FILENAME = "/data/misc/wmtrace/transaction_trace.pb"; 52 53 class SurfaceInterceptor : public IBinder::DeathRecipient { 54 public: 55 virtual ~SurfaceInterceptor(); 56 57 // Both vectors are used to capture the current state of SF as the initial snapshot in the trace 58 virtual void enable(const SortedVector<sp<Layer>>& layers, 59 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays) = 0; 60 virtual void disable() = 0; 61 virtual bool isEnabled() = 0; 62 63 virtual void addTransactionTraceListener( 64 const sp<gui::ITransactionTraceListener>& listener) = 0; 65 virtual void binderDied(const wp<IBinder>& who) = 0; 66 67 // Intercept display and surface transactions 68 virtual void saveTransaction( 69 const Vector<ComposerState>& stateUpdates, 70 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays, 71 const Vector<DisplayState>& changedDisplays, uint32_t flags, int originPid, 72 int originUid, uint64_t transactionId) = 0; 73 74 // Intercept surface data 75 virtual void saveSurfaceCreation(const sp<const Layer>& layer) = 0; 76 virtual void saveSurfaceDeletion(const sp<const Layer>& layer) = 0; 77 virtual void saveBufferUpdate(int32_t layerId, uint32_t width, uint32_t height, 78 uint64_t frameNumber) = 0; 79 80 // Intercept display data 81 virtual void saveDisplayCreation(const DisplayDeviceState& info) = 0; 82 virtual void saveDisplayDeletion(int32_t sequenceId) = 0; 83 virtual void savePowerModeUpdate(int32_t sequenceId, int32_t mode) = 0; 84 virtual void saveVSyncEvent(nsecs_t timestamp) = 0; 85 }; 86 87 namespace impl { 88 89 /* 90 * SurfaceInterceptor intercepts and stores incoming streams of window 91 * properties on SurfaceFlinger. 92 */ 93 class SurfaceInterceptor final : public android::SurfaceInterceptor { 94 public: 95 SurfaceInterceptor() = default; 96 ~SurfaceInterceptor() override = default; 97 98 // Both vectors are used to capture the current state of SF as the initial snapshot in the trace 99 void enable(const SortedVector<sp<Layer>>& layers, 100 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays) override; 101 void disable() override; 102 bool isEnabled() override; 103 104 void addTransactionTraceListener(const sp<gui::ITransactionTraceListener>& listener) override; 105 void binderDied(const wp<IBinder>& who) override; 106 107 // Intercept display and surface transactions 108 void saveTransaction(const Vector<ComposerState>& stateUpdates, 109 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays, 110 const Vector<DisplayState>& changedDisplays, uint32_t flags, int originPid, 111 int originUid, uint64_t transactionId) override; 112 113 // Intercept surface data 114 void saveSurfaceCreation(const sp<const Layer>& layer) override; 115 void saveSurfaceDeletion(const sp<const Layer>& layer) override; 116 void saveBufferUpdate(int32_t layerId, uint32_t width, uint32_t height, 117 uint64_t frameNumber) override; 118 119 // Intercept display data 120 void saveDisplayCreation(const DisplayDeviceState& info) override; 121 void saveDisplayDeletion(int32_t sequenceId) override; 122 void savePowerModeUpdate(int32_t sequenceId, int32_t mode) override; 123 void saveVSyncEvent(nsecs_t timestamp) override; 124 125 private: 126 // The creation increments of Surfaces and Displays do not contain enough information to capture 127 // the initial state of each object, so a transaction with all of the missing properties is 128 // performed at the initial snapshot for each display and surface. 129 void saveExistingDisplaysLocked( 130 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays); 131 void saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers); 132 void addInitialSurfaceStateLocked(Increment* increment, const sp<const Layer>& layer); 133 void addInitialDisplayStateLocked(Increment* increment, const DisplayDeviceState& display); 134 135 status_t writeProtoFileLocked(); 136 const sp<const Layer> getLayer(const wp<const IBinder>& weakHandle) const; 137 int32_t getLayerId(const sp<const Layer>& layer) const; 138 int32_t getLayerIdFromWeakRef(const wp<const Layer>& layer) const; 139 int32_t getLayerIdFromHandle(const sp<const IBinder>& weakHandle) const; 140 141 Increment* createTraceIncrementLocked(); 142 void addSurfaceCreationLocked(Increment* increment, const sp<const Layer>& layer); 143 void addSurfaceDeletionLocked(Increment* increment, const sp<const Layer>& layer); 144 void addBufferUpdateLocked(Increment* increment, int32_t layerId, uint32_t width, 145 uint32_t height, uint64_t frameNumber); 146 void addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp); 147 void addDisplayCreationLocked(Increment* increment, const DisplayDeviceState& info); 148 void addDisplayDeletionLocked(Increment* increment, int32_t sequenceId); 149 void addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId, int32_t mode); 150 151 // Add surface transactions to the trace 152 SurfaceChange* createSurfaceChangeLocked(Transaction* transaction, int32_t layerId); 153 void setProtoRectLocked(Rectangle* protoRect, const Rect& rect); 154 void addPositionLocked(Transaction* transaction, int32_t layerId, float x, float y); 155 void addDepthLocked(Transaction* transaction, int32_t layerId, uint32_t z); 156 void addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w, uint32_t h); 157 void addAlphaLocked(Transaction* transaction, int32_t layerId, float alpha); 158 void addMatrixLocked(Transaction* transaction, int32_t layerId, 159 const layer_state_t::matrix22_t& matrix); 160 void addTransparentRegionLocked(Transaction* transaction, int32_t layerId, 161 const Region& transRegion); 162 void addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags, uint8_t mask); 163 void addLayerStackLocked(Transaction* transaction, int32_t layerId, uint32_t layerStack); 164 void addCropLocked(Transaction* transaction, int32_t layerId, const Rect& rect); 165 void addCornerRadiusLocked(Transaction* transaction, int32_t layerId, float cornerRadius); 166 void addBackgroundBlurRadiusLocked(Transaction* transaction, int32_t layerId, 167 int32_t backgroundBlurRadius); 168 void addBlurRegionsLocked(Transaction* transaction, int32_t layerId, 169 const std::vector<BlurRegion>& effectRegions); 170 void addSurfaceChangesLocked(Transaction* transaction, const layer_state_t& state); 171 void addTransactionLocked(Increment* increment, const Vector<ComposerState>& stateUpdates, 172 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays, 173 const Vector<DisplayState>& changedDisplays, 174 uint32_t transactionFlags, int originPid, int originUid, 175 uint64_t transactionId); 176 void addReparentLocked(Transaction* transaction, int32_t layerId, int32_t parentId); 177 void addRelativeParentLocked(Transaction* transaction, int32_t layerId, int32_t parentId, 178 int z); 179 void addShadowRadiusLocked(Transaction* transaction, int32_t layerId, float shadowRadius); 180 void addTrustedOverlayLocked(Transaction* transaction, int32_t layerId, bool isTrustedOverlay); 181 182 // Add display transactions to the trace 183 DisplayChange* createDisplayChangeLocked(Transaction* transaction, int32_t sequenceId); 184 void addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId, 185 const sp<const IGraphicBufferProducer>& surface); 186 void addDisplayLayerStackLocked(Transaction* transaction, int32_t sequenceId, 187 uint32_t layerStack); 188 void addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId, uint32_t w, 189 uint32_t h); 190 void addDisplayProjectionLocked(Transaction* transaction, int32_t sequenceId, 191 int32_t orientation, const Rect& viewport, const Rect& frame); 192 void addDisplayChangesLocked(Transaction* transaction, 193 const DisplayState& state, int32_t sequenceId); 194 195 // Add transaction origin to trace 196 void setTransactionOriginLocked(Transaction* transaction, int32_t pid, int32_t uid); 197 198 bool mEnabled {false}; 199 std::string mOutputFileName {DEFAULT_FILENAME}; 200 std::mutex mTraceMutex {}; 201 Trace mTrace {}; 202 std::mutex mListenersMutex; 203 std::map<wp<IBinder>, sp<gui::ITransactionTraceListener>> mTraceToggledListeners 204 GUARDED_BY(mListenersMutex); 205 }; 206 207 } // namespace impl 208 209 } // namespace android 210 211 #endif // ANDROID_SURFACEINTERCEPTOR_H 212