blob: 6797aa697b4d2619778f3d80710a0d27180b2d50 [file] [log] [blame]
Irvelc274c632016-06-13 16:44:08 -07001/*
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 */
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -080016
17// TODO(b/129481165): remove the #pragma below and fix conversion issues
18#pragma clang diagnostic push
19#pragma clang diagnostic ignored "-Wconversion"
Irvelc274c632016-06-13 16:44:08 -070020#undef LOG_TAG
21#define LOG_TAG "SurfaceInterceptor"
22#define ATRACE_TAG ATRACE_TAG_GRAPHICS
23
24#include "Layer.h"
25#include "SurfaceFlinger.h"
26#include "SurfaceInterceptor.h"
Colin Cross63549382016-10-26 12:52:53 -070027
Irvelc274c632016-06-13 16:44:08 -070028#include <fstream>
29
Mark Salyzyn4dad9ce2016-09-29 08:08:05 -070030#include <android-base/file.h>
31#include <log/log.h>
32#include <utils/Trace.h>
33
Irvelc274c632016-06-13 16:44:08 -070034namespace android {
35
36// ----------------------------------------------------------------------------
Marissa Wall61c58622018-07-18 10:12:20 -070037// TODO(marissaw): add new layer state values to SurfaceInterceptor
Irvelc274c632016-06-13 16:44:08 -070038
Lloyd Pique4dccc412018-01-22 17:21:36 -080039SurfaceInterceptor::~SurfaceInterceptor() = default;
40
41namespace impl {
42
Pablo Gamito6ee484d2020-07-30 14:26:28 +000043void SurfaceInterceptor::addTransactionTraceListener(
44 const sp<gui::ITransactionTraceListener>& listener) {
45 sp<IBinder> asBinder = IInterface::asBinder(listener);
46
47 std::scoped_lock lock(mListenersMutex);
48
Ady Abrahamd11bade2022-08-01 16:18:03 -070049 asBinder->linkToDeath(sp<DeathRecipient>::fromExisting(this));
Pablo Gamito6ee484d2020-07-30 14:26:28 +000050
51 listener->onToggled(mEnabled); // notifies of current state
52
53 mTraceToggledListeners.emplace(asBinder, listener);
54}
55
Pablo Gamito5cfc6e52020-09-10 11:18:03 +000056void SurfaceInterceptor::binderDied(const wp<IBinder>& who) {
Pablo Gamito6ee484d2020-07-30 14:26:28 +000057 std::scoped_lock lock(mListenersMutex);
58 mTraceToggledListeners.erase(who);
Pablo Gamito5cfc6e52020-09-10 11:18:03 +000059}
60
Irvelffc9efc2016-07-27 15:16:37 -070061void SurfaceInterceptor::enable(const SortedVector<sp<Layer>>& layers,
62 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays)
63{
Irvelc274c632016-06-13 16:44:08 -070064 if (mEnabled) {
65 return;
66 }
Irvelffc9efc2016-07-27 15:16:37 -070067 ATRACE_CALL();
Pablo Gamito6ee484d2020-07-30 14:26:28 +000068 {
69 std::scoped_lock lock(mListenersMutex);
70 for (const auto& [_, listener] : mTraceToggledListeners) {
71 listener->onToggled(true);
72 }
73 }
Irvelc274c632016-06-13 16:44:08 -070074 mEnabled = true;
Pablo Gamito6ee484d2020-07-30 14:26:28 +000075 std::scoped_lock<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -070076 saveExistingDisplaysLocked(displays);
77 saveExistingSurfacesLocked(layers);
Irvelc274c632016-06-13 16:44:08 -070078}
79
80void SurfaceInterceptor::disable() {
Irvelc274c632016-06-13 16:44:08 -070081 if (!mEnabled) {
82 return;
83 }
Irvelffc9efc2016-07-27 15:16:37 -070084 ATRACE_CALL();
Pablo Gamito6ee484d2020-07-30 14:26:28 +000085 {
86 std::scoped_lock lock(mListenersMutex);
87 for (const auto& [_, listener] : mTraceToggledListeners) {
88 listener->onToggled(false);
89 }
90 }
Irvelc274c632016-06-13 16:44:08 -070091 mEnabled = false;
Pablo Gamito6ee484d2020-07-30 14:26:28 +000092 std::scoped_lock<std::mutex> protoGuard(mTraceMutex);
Irvelc274c632016-06-13 16:44:08 -070093 status_t err(writeProtoFileLocked());
94 ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied");
95 ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields");
96 mTrace.Clear();
97}
98
Irvelffc9efc2016-07-27 15:16:37 -070099bool SurfaceInterceptor::isEnabled() {
100 return mEnabled;
101}
102
103void SurfaceInterceptor::saveExistingDisplaysLocked(
104 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays)
105{
106 // Caveat: The initial snapshot does not capture the power mode of the existing displays
Irvelc274c632016-06-13 16:44:08 -0700107 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700108 for (size_t i = 0 ; i < displays.size() ; i++) {
109 addDisplayCreationLocked(createTraceIncrementLocked(), displays[i]);
110 addInitialDisplayStateLocked(createTraceIncrementLocked(), displays[i]);
Irvelc274c632016-06-13 16:44:08 -0700111 }
112}
113
Irvelffc9efc2016-07-27 15:16:37 -0700114void SurfaceInterceptor::saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers) {
Irvelc274c632016-06-13 16:44:08 -0700115 ATRACE_CALL();
Robert Carr1f0a16a2016-10-24 16:27:39 -0700116 for (const auto& l : layers) {
Dan Stoza412903f2017-04-27 13:42:17 -0700117 l->traverseInZOrder(LayerVector::StateSet::Drawing, [this](Layer* layer) {
Ady Abrahamd11bade2022-08-01 16:18:03 -0700118 addSurfaceCreationLocked(createTraceIncrementLocked(), sp<Layer>::fromExisting(layer));
119 addInitialSurfaceStateLocked(createTraceIncrementLocked(),
120 sp<Layer>::fromExisting(layer));
Robert Carr1f0a16a2016-10-24 16:27:39 -0700121 });
Irvelc274c632016-06-13 16:44:08 -0700122 }
Irvelffc9efc2016-07-27 15:16:37 -0700123}
124
125void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment,
126 const sp<const Layer>& layer)
127{
Irvelc274c632016-06-13 16:44:08 -0700128 Transaction* transaction(increment->mutable_transaction());
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700129 const uint32_t layerFlags = layer->getTransactionFlags();
130 transaction->set_synchronous(layerFlags & BnSurfaceComposer::eSynchronous);
131 transaction->set_animation(layerFlags & BnSurfaceComposer::eAnimation);
Irvelc274c632016-06-13 16:44:08 -0700132
133 const int32_t layerId(getLayerId(layer));
Robert Carr6a160312021-05-17 12:08:20 -0700134 addPositionLocked(transaction, layerId, layer->mDrawingState.transform.tx(),
135 layer->mDrawingState.transform.ty());
136 addDepthLocked(transaction, layerId, layer->mDrawingState.z);
137 addAlphaLocked(transaction, layerId, layer->mDrawingState.color.a);
Robert Carr6a160312021-05-17 12:08:20 -0700138 addLayerStackLocked(transaction, layerId, layer->mDrawingState.layerStack);
139 addCropLocked(transaction, layerId, layer->mDrawingState.crop);
140 addCornerRadiusLocked(transaction, layerId, layer->mDrawingState.cornerRadius);
141 addBackgroundBlurRadiusLocked(transaction, layerId, layer->mDrawingState.backgroundBlurRadius);
142 addBlurRegionsLocked(transaction, layerId, layer->mDrawingState.blurRegions);
143 addFlagsLocked(transaction, layerId, layer->mDrawingState.flags,
Vishnu Nair456bbb22019-07-18 16:02:00 -0700144 layer_state_t::eLayerHidden | layer_state_t::eLayerOpaque |
145 layer_state_t::eLayerSecure);
Robert Carr6a160312021-05-17 12:08:20 -0700146 addReparentLocked(transaction, layerId, getLayerIdFromWeakRef(layer->mDrawingParent));
Vishnu Nair456bbb22019-07-18 16:02:00 -0700147 addRelativeParentLocked(transaction, layerId,
Robert Carr6a160312021-05-17 12:08:20 -0700148 getLayerIdFromWeakRef(layer->mDrawingState.zOrderRelativeOf),
149 layer->mDrawingState.z);
150 addShadowRadiusLocked(transaction, layerId, layer->mDrawingState.shadowRadius);
Winson Chunga30f7c92021-06-29 15:42:56 -0700151 addTrustedOverlayLocked(transaction, layerId, layer->mDrawingState.isTrustedOverlay);
Irvelc274c632016-06-13 16:44:08 -0700152}
153
Irvelffc9efc2016-07-27 15:16:37 -0700154void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment,
155 const DisplayDeviceState& display)
156{
157 Transaction* transaction(increment->mutable_transaction());
158 transaction->set_synchronous(false);
159 transaction->set_animation(false);
160
Dominik Laskowski663bd282018-04-19 15:26:54 -0700161 addDisplaySurfaceLocked(transaction, display.sequenceId, display.surface);
162 addDisplayLayerStackLocked(transaction, display.sequenceId, display.layerStack);
Evan Rosky2239b372021-05-20 13:43:47 -0700163 addDisplayFlagsLocked(transaction, display.sequenceId, display.flags);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700164 addDisplaySizeLocked(transaction, display.sequenceId, display.width, display.height);
Dominik Laskowski718f9602019-11-09 20:01:35 -0800165 addDisplayProjectionLocked(transaction, display.sequenceId, toRotationInt(display.orientation),
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200166 display.layerStackSpaceRect, display.orientedDisplaySpaceRect);
Irvelffc9efc2016-07-27 15:16:37 -0700167}
168
Irvelc274c632016-06-13 16:44:08 -0700169status_t SurfaceInterceptor::writeProtoFileLocked() {
170 ATRACE_CALL();
Colin Cross63549382016-10-26 12:52:53 -0700171 std::string output;
172
Irvelc274c632016-06-13 16:44:08 -0700173 if (!mTrace.IsInitialized()) {
174 return NOT_ENOUGH_DATA;
175 }
Colin Cross63549382016-10-26 12:52:53 -0700176 if (!mTrace.SerializeToString(&output)) {
Irvelc274c632016-06-13 16:44:08 -0700177 return PERMISSION_DENIED;
178 }
Colin Cross63549382016-10-26 12:52:53 -0700179 if (!android::base::WriteStringToFile(output, mOutputFileName, true)) {
180 return PERMISSION_DENIED;
181 }
182
Irvelc274c632016-06-13 16:44:08 -0700183 return NO_ERROR;
184}
185
Vishnu Nairf9096652021-07-20 18:49:42 -0700186const sp<const Layer> SurfaceInterceptor::getLayer(const wp<IBinder>& weakHandle) const {
187 sp<IBinder> handle = weakHandle.promote();
188 return Layer::fromHandle(handle).promote();
Irvelc274c632016-06-13 16:44:08 -0700189}
190
Vishnu Nair456bbb22019-07-18 16:02:00 -0700191int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) const {
Irvelc274c632016-06-13 16:44:08 -0700192 return layer->sequence;
193}
194
Vishnu Nair456bbb22019-07-18 16:02:00 -0700195int32_t SurfaceInterceptor::getLayerIdFromWeakRef(const wp<const Layer>& layer) const {
196 if (layer == nullptr) {
197 return -1;
198 }
199 auto strongLayer = layer.promote();
200 return strongLayer == nullptr ? -1 : getLayerId(strongLayer);
201}
202
Vishnu Nairf9096652021-07-20 18:49:42 -0700203int32_t SurfaceInterceptor::getLayerIdFromHandle(const sp<IBinder>& handle) const {
Vishnu Nair456bbb22019-07-18 16:02:00 -0700204 if (handle == nullptr) {
205 return -1;
206 }
Vishnu Nairf9096652021-07-20 18:49:42 -0700207 const sp<const Layer> layer = Layer::fromHandle(handle).promote();
Vishnu Nair456bbb22019-07-18 16:02:00 -0700208 return layer == nullptr ? -1 : getLayerId(layer);
209}
210
Irvelffc9efc2016-07-27 15:16:37 -0700211Increment* SurfaceInterceptor::createTraceIncrementLocked() {
Irvelc274c632016-06-13 16:44:08 -0700212 Increment* increment(mTrace.add_increment());
Vishnu Nair45cb21a2020-03-27 17:39:24 -0700213 increment->set_time_stamp(elapsedRealtimeNano());
Irvelc274c632016-06-13 16:44:08 -0700214 return increment;
215}
216
Irvelffc9efc2016-07-27 15:16:37 -0700217SurfaceChange* SurfaceInterceptor::createSurfaceChangeLocked(Transaction* transaction,
218 int32_t layerId)
219{
220 SurfaceChange* change(transaction->add_surface_change());
Irvelc274c632016-06-13 16:44:08 -0700221 change->set_id(layerId);
222 return change;
223}
224
Irvelffc9efc2016-07-27 15:16:37 -0700225DisplayChange* SurfaceInterceptor::createDisplayChangeLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700226 int32_t sequenceId)
Irvelffc9efc2016-07-27 15:16:37 -0700227{
228 DisplayChange* dispChange(transaction->add_display_change());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700229 dispChange->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700230 return dispChange;
231}
232
Irvelc274c632016-06-13 16:44:08 -0700233void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) {
234 protoRect->set_left(rect.left);
235 protoRect->set_top(rect.top);
236 protoRect->set_right(rect.right);
237 protoRect->set_bottom(rect.bottom);
238}
239
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000240void SurfaceInterceptor::setTransactionOriginLocked(Transaction* transaction, int32_t pid,
241 int32_t uid) {
242 Origin* origin(transaction->mutable_origin());
243 origin->set_pid(pid);
244 origin->set_uid(uid);
245}
246
Irvelffc9efc2016-07-27 15:16:37 -0700247void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId,
248 float x, float y)
Irvelc274c632016-06-13 16:44:08 -0700249{
Irvelffc9efc2016-07-27 15:16:37 -0700250 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700251 PositionChange* posChange(change->mutable_position());
252 posChange->set_x(x);
253 posChange->set_y(y);
254}
255
Irvelffc9efc2016-07-27 15:16:37 -0700256void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId,
257 uint32_t z)
258{
259 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700260 LayerChange* depthChange(change->mutable_layer());
261 depthChange->set_layer(z);
262}
263
264void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w,
265 uint32_t h)
266{
Irvelffc9efc2016-07-27 15:16:37 -0700267 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700268 SizeChange* sizeChange(change->mutable_size());
269 sizeChange->set_w(w);
270 sizeChange->set_h(h);
271}
272
Irvelffc9efc2016-07-27 15:16:37 -0700273void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId,
274 float alpha)
275{
276 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700277 AlphaChange* alphaChange(change->mutable_alpha());
278 alphaChange->set_alpha(alpha);
279}
280
281void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId,
282 const layer_state_t::matrix22_t& matrix)
283{
Irvelffc9efc2016-07-27 15:16:37 -0700284 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700285 MatrixChange* matrixChange(change->mutable_matrix());
286 matrixChange->set_dsdx(matrix.dsdx);
287 matrixChange->set_dtdx(matrix.dtdx);
288 matrixChange->set_dsdy(matrix.dsdy);
289 matrixChange->set_dtdy(matrix.dtdy);
290}
291
Irvelffc9efc2016-07-27 15:16:37 -0700292void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction,
293 int32_t layerId, const Region& transRegion)
Irvelc274c632016-06-13 16:44:08 -0700294{
Irvelffc9efc2016-07-27 15:16:37 -0700295 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700296 TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint());
297
298 for (const auto& rect : transRegion) {
299 Rectangle* protoRect(transparentChange->add_region());
300 setProtoRectLocked(protoRect, rect);
301 }
302}
303
Vishnu Nair456bbb22019-07-18 16:02:00 -0700304void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags,
305 uint8_t mask) {
Irvelc274c632016-06-13 16:44:08 -0700306 // There can be multiple flags changed
Vishnu Nair456bbb22019-07-18 16:02:00 -0700307 if (mask & layer_state_t::eLayerHidden) {
Irvelffc9efc2016-07-27 15:16:37 -0700308 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700309 HiddenFlagChange* flagChange(change->mutable_hidden_flag());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700310 flagChange->set_hidden_flag(flags & layer_state_t::eLayerHidden);
Irvelc274c632016-06-13 16:44:08 -0700311 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700312 if (mask & layer_state_t::eLayerOpaque) {
Irvelffc9efc2016-07-27 15:16:37 -0700313 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700314 OpaqueFlagChange* flagChange(change->mutable_opaque_flag());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700315 flagChange->set_opaque_flag(flags & layer_state_t::eLayerOpaque);
Irvelc274c632016-06-13 16:44:08 -0700316 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700317 if (mask & layer_state_t::eLayerSecure) {
Irvelffc9efc2016-07-27 15:16:37 -0700318 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700319 SecureFlagChange* flagChange(change->mutable_secure_flag());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700320 flagChange->set_secure_flag(flags & layer_state_t::eLayerSecure);
Irvelc274c632016-06-13 16:44:08 -0700321 }
322}
323
324void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId,
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700325 ui::LayerStack layerStack) {
Irvelffc9efc2016-07-27 15:16:37 -0700326 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700327 LayerStackChange* layerStackChange(change->mutable_layer_stack());
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700328 layerStackChange->set_layer_stack(layerStack.id);
Irvelc274c632016-06-13 16:44:08 -0700329}
330
331void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
332 const Rect& rect)
333{
Irvelffc9efc2016-07-27 15:16:37 -0700334 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700335 CropChange* cropChange(change->mutable_crop());
336 Rectangle* protoRect(cropChange->mutable_rectangle());
337 setProtoRectLocked(protoRect, rect);
338}
339
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700340void SurfaceInterceptor::addCornerRadiusLocked(Transaction* transaction, int32_t layerId,
341 float cornerRadius)
342{
343 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
344 CornerRadiusChange* cornerRadiusChange(change->mutable_corner_radius());
345 cornerRadiusChange->set_corner_radius(cornerRadius);
346}
347
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800348void SurfaceInterceptor::addBackgroundBlurRadiusLocked(Transaction* transaction, int32_t layerId,
349 int32_t backgroundBlurRadius) {
350 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
351 BackgroundBlurRadiusChange* blurRadiusChange(change->mutable_background_blur_radius());
352 blurRadiusChange->set_background_blur_radius(backgroundBlurRadius);
353}
354
Lucas Dupinc3800b82020-10-02 16:24:48 -0700355void SurfaceInterceptor::addBlurRegionsLocked(Transaction* transaction, int32_t layerId,
356 const std::vector<BlurRegion>& blurRegions) {
357 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
358 BlurRegionsChange* blurRegionsChange(change->mutable_blur_regions());
359 for (const auto blurRegion : blurRegions) {
360 const auto blurRegionChange = blurRegionsChange->add_blur_regions();
361 blurRegionChange->set_blur_radius(blurRegion.blurRadius);
362 blurRegionChange->set_corner_radius_tl(blurRegion.cornerRadiusTL);
363 blurRegionChange->set_corner_radius_tr(blurRegion.cornerRadiusTR);
364 blurRegionChange->set_corner_radius_bl(blurRegion.cornerRadiusBL);
365 blurRegionChange->set_corner_radius_br(blurRegion.cornerRadiusBR);
366 blurRegionChange->set_alpha(blurRegion.alpha);
367 blurRegionChange->set_left(blurRegion.left);
368 blurRegionChange->set_top(blurRegion.top);
369 blurRegionChange->set_right(blurRegion.right);
370 blurRegionChange->set_bottom(blurRegion.bottom);
371 }
372}
373
Vishnu Nair456bbb22019-07-18 16:02:00 -0700374void SurfaceInterceptor::addReparentLocked(Transaction* transaction, int32_t layerId,
375 int32_t parentId) {
376 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
377 ReparentChange* overrideChange(change->mutable_reparent());
378 overrideChange->set_parent_id(parentId);
379}
380
Vishnu Nair456bbb22019-07-18 16:02:00 -0700381void SurfaceInterceptor::addRelativeParentLocked(Transaction* transaction, int32_t layerId,
382 int32_t parentId, int z) {
383 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
384 RelativeParentChange* overrideChange(change->mutable_relative_parent());
385 overrideChange->set_relative_parent_id(parentId);
386 overrideChange->set_z(z);
387}
388
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800389void SurfaceInterceptor::addShadowRadiusLocked(Transaction* transaction, int32_t layerId,
390 float shadowRadius) {
391 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
392 ShadowRadiusChange* overrideChange(change->mutable_shadow_radius());
393 overrideChange->set_radius(shadowRadius);
394}
395
Winson Chunga30f7c92021-06-29 15:42:56 -0700396void SurfaceInterceptor::addTrustedOverlayLocked(Transaction* transaction, int32_t layerId,
397 bool isTrustedOverlay) {
398 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
399 TrustedOverlayChange* overrideChange(change->mutable_trusted_overlay());
400 overrideChange->set_is_trusted_overlay(isTrustedOverlay);
401}
402
Irvelffc9efc2016-07-27 15:16:37 -0700403void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction,
Irvelc274c632016-06-13 16:44:08 -0700404 const layer_state_t& state)
405{
406 const sp<const Layer> layer(getLayer(state.surface));
407 if (layer == nullptr) {
408 ALOGE("An existing layer could not be retrieved with the surface "
409 "from the layer_state_t surface in the update transaction");
410 return;
411 }
412
413 const int32_t layerId(getLayerId(layer));
414
415 if (state.what & layer_state_t::ePositionChanged) {
416 addPositionLocked(transaction, layerId, state.x, state.y);
417 }
418 if (state.what & layer_state_t::eLayerChanged) {
419 addDepthLocked(transaction, layerId, state.z);
420 }
Irvelc274c632016-06-13 16:44:08 -0700421 if (state.what & layer_state_t::eAlphaChanged) {
422 addAlphaLocked(transaction, layerId, state.alpha);
423 }
424 if (state.what & layer_state_t::eMatrixChanged) {
425 addMatrixLocked(transaction, layerId, state.matrix);
426 }
427 if (state.what & layer_state_t::eTransparentRegionChanged) {
428 addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
429 }
430 if (state.what & layer_state_t::eFlagsChanged) {
Vishnu Nair456bbb22019-07-18 16:02:00 -0700431 addFlagsLocked(transaction, layerId, state.flags, state.mask);
Irvelc274c632016-06-13 16:44:08 -0700432 }
433 if (state.what & layer_state_t::eLayerStackChanged) {
434 addLayerStackLocked(transaction, layerId, state.layerStack);
435 }
chaviw25714502021-02-11 10:01:08 -0800436 if (state.what & layer_state_t::eCropChanged) {
437 addCropLocked(transaction, layerId, state.crop);
Irvelc274c632016-06-13 16:44:08 -0700438 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700439 if (state.what & layer_state_t::eCornerRadiusChanged) {
440 addCornerRadiusLocked(transaction, layerId, state.cornerRadius);
441 }
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800442 if (state.what & layer_state_t::eBackgroundBlurRadiusChanged) {
443 addBackgroundBlurRadiusLocked(transaction, layerId, state.backgroundBlurRadius);
444 }
Lucas Dupinc3800b82020-10-02 16:24:48 -0700445 if (state.what & layer_state_t::eBlurRegionsChanged) {
446 addBlurRegionsLocked(transaction, layerId, state.blurRegions);
447 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700448 if (state.what & layer_state_t::eReparent) {
Pablo Gamito11dcc222020-09-12 15:49:39 +0000449 auto parentHandle = (state.parentSurfaceControlForChild)
450 ? state.parentSurfaceControlForChild->getHandle()
451 : nullptr;
452 addReparentLocked(transaction, layerId, getLayerIdFromHandle(parentHandle));
Vishnu Nair456bbb22019-07-18 16:02:00 -0700453 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700454 if (state.what & layer_state_t::eRelativeLayerChanged) {
455 addRelativeParentLocked(transaction, layerId,
Pablo Gamito11dcc222020-09-12 15:49:39 +0000456 getLayerIdFromHandle(
457 state.relativeLayerSurfaceControl->getHandle()),
458 state.z);
Vishnu Nair456bbb22019-07-18 16:02:00 -0700459 }
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800460 if (state.what & layer_state_t::eShadowRadiusChanged) {
461 addShadowRadiusLocked(transaction, layerId, state.shadowRadius);
462 }
Winson Chunga30f7c92021-06-29 15:42:56 -0700463 if (state.what & layer_state_t::eTrustedOverlayChanged) {
464 addTrustedOverlayLocked(transaction, layerId, state.isTrustedOverlay);
465 }
John Reckc00c6692021-02-16 11:37:33 -0500466 if (state.what & layer_state_t::eStretchChanged) {
467 ALOGW("SurfaceInterceptor not implemented for eStretchChanged");
468 }
Irvelc274c632016-06-13 16:44:08 -0700469}
470
Irvelffc9efc2016-07-27 15:16:37 -0700471void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700472 const DisplayState& state, int32_t sequenceId)
Irvelc274c632016-06-13 16:44:08 -0700473{
Irvelffc9efc2016-07-27 15:16:37 -0700474 if (state.what & DisplayState::eSurfaceChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700475 addDisplaySurfaceLocked(transaction, sequenceId, state.surface);
Irvelffc9efc2016-07-27 15:16:37 -0700476 }
477 if (state.what & DisplayState::eLayerStackChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700478 addDisplayLayerStackLocked(transaction, sequenceId, state.layerStack);
Irvelffc9efc2016-07-27 15:16:37 -0700479 }
Evan Rosky2239b372021-05-20 13:43:47 -0700480 if (state.what & DisplayState::eFlagsChanged) {
481 addDisplayFlagsLocked(transaction, sequenceId, state.flags);
482 }
Irvelffc9efc2016-07-27 15:16:37 -0700483 if (state.what & DisplayState::eDisplaySizeChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700484 addDisplaySizeLocked(transaction, sequenceId, state.width, state.height);
Irvelffc9efc2016-07-27 15:16:37 -0700485 }
486 if (state.what & DisplayState::eDisplayProjectionChanged) {
Dominik Laskowski718f9602019-11-09 20:01:35 -0800487 addDisplayProjectionLocked(transaction, sequenceId, toRotationInt(state.orientation),
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200488 state.layerStackSpaceRect, state.orientedDisplaySpaceRect);
Irvelc274c632016-06-13 16:44:08 -0700489 }
490}
491
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000492void SurfaceInterceptor::addTransactionLocked(
493 Increment* increment, const Vector<ComposerState>& stateUpdates,
494 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000495 const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags, int originPid,
496 int originUid, uint64_t transactionId) {
Irvelffc9efc2016-07-27 15:16:37 -0700497 Transaction* transaction(increment->mutable_transaction());
498 transaction->set_synchronous(transactionFlags & BnSurfaceComposer::eSynchronous);
499 transaction->set_animation(transactionFlags & BnSurfaceComposer::eAnimation);
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000500 setTransactionOriginLocked(transaction, originPid, originUid);
501 transaction->set_id(transactionId);
Irvelffc9efc2016-07-27 15:16:37 -0700502 for (const auto& compState: stateUpdates) {
503 addSurfaceChangesLocked(transaction, compState.state);
504 }
505 for (const auto& disp: changedDisplays) {
506 ssize_t dpyIdx = displays.indexOfKey(disp.token);
507 if (dpyIdx >= 0) {
508 const DisplayDeviceState& dispState(displays.valueAt(dpyIdx));
Dominik Laskowski663bd282018-04-19 15:26:54 -0700509 addDisplayChangesLocked(transaction, disp, dispState.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700510 }
511 }
Irvelc274c632016-06-13 16:44:08 -0700512}
513
Irvelffc9efc2016-07-27 15:16:37 -0700514void SurfaceInterceptor::addSurfaceCreationLocked(Increment* increment,
515 const sp<const Layer>& layer)
516{
517 SurfaceCreation* creation(increment->mutable_surface_creation());
518 creation->set_id(getLayerId(layer));
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700519 creation->set_name(layer->getName());
Irvelc274c632016-06-13 16:44:08 -0700520}
521
Irvelffc9efc2016-07-27 15:16:37 -0700522void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
523 const sp<const Layer>& layer)
524{
525 SurfaceDeletion* deletion(increment->mutable_surface_deletion());
526 deletion->set_id(getLayerId(layer));
527}
528
Rob Carra79435b2020-03-06 14:46:07 -0800529void SurfaceInterceptor::addBufferUpdateLocked(Increment* increment, int32_t layerId,
Irvelc274c632016-06-13 16:44:08 -0700530 uint32_t width, uint32_t height, uint64_t frameNumber)
531{
532 BufferUpdate* update(increment->mutable_buffer_update());
Rob Carra79435b2020-03-06 14:46:07 -0800533 update->set_id(layerId);
Irvelc274c632016-06-13 16:44:08 -0700534 update->set_w(width);
535 update->set_h(height);
536 update->set_frame_number(frameNumber);
537}
538
Irvelffc9efc2016-07-27 15:16:37 -0700539void SurfaceInterceptor::addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp) {
Irvelc274c632016-06-13 16:44:08 -0700540 VSyncEvent* event(increment->mutable_vsync_event());
541 event->set_when(timestamp);
542}
543
Dominik Laskowski663bd282018-04-19 15:26:54 -0700544void SurfaceInterceptor::addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700545 const sp<const IGraphicBufferProducer>& surface)
Irvelc274c632016-06-13 16:44:08 -0700546{
Irvelffc9efc2016-07-27 15:16:37 -0700547 if (surface == nullptr) {
Irvelc274c632016-06-13 16:44:08 -0700548 return;
549 }
Irvelffc9efc2016-07-27 15:16:37 -0700550 uint64_t bufferQueueId = 0;
551 status_t err(surface->getUniqueId(&bufferQueueId));
552 if (err == NO_ERROR) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700553 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700554 DispSurfaceChange* surfaceChange(dispChange->mutable_surface());
555 surfaceChange->set_buffer_queue_id(bufferQueueId);
556 surfaceChange->set_buffer_queue_name(surface->getConsumerName().string());
557 }
558 else {
559 ALOGE("invalid graphic buffer producer received while tracing a display change (%s)",
560 strerror(-err));
561 }
Irvelc274c632016-06-13 16:44:08 -0700562}
563
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700564void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction, int32_t sequenceId,
565 ui::LayerStack layerStack) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700566 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700567 LayerStackChange* layerStackChange(dispChange->mutable_layer_stack());
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700568 layerStackChange->set_layer_stack(layerStack.id);
Irvelffc9efc2016-07-27 15:16:37 -0700569}
570
Evan Rosky2239b372021-05-20 13:43:47 -0700571void SurfaceInterceptor::addDisplayFlagsLocked(Transaction* transaction, int32_t sequenceId,
572 uint32_t flags) {
573 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
574 DisplayFlagsChange* flagsChange(dispChange->mutable_flags());
575 flagsChange->set_flags(flags);
576}
577
Dominik Laskowski663bd282018-04-19 15:26:54 -0700578void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700579 uint32_t w, uint32_t h)
580{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700581 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700582 SizeChange* sizeChange(dispChange->mutable_size());
583 sizeChange->set_w(w);
584 sizeChange->set_h(h);
585}
586
587void SurfaceInterceptor::addDisplayProjectionLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700588 int32_t sequenceId, int32_t orientation, const Rect& viewport, const Rect& frame)
Irvelffc9efc2016-07-27 15:16:37 -0700589{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700590 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700591 ProjectionChange* projectionChange(dispChange->mutable_projection());
592 projectionChange->set_orientation(orientation);
593 Rectangle* viewportRect(projectionChange->mutable_viewport());
594 setProtoRectLocked(viewportRect, viewport);
595 Rectangle* frameRect(projectionChange->mutable_frame());
596 setProtoRectLocked(frameRect, frame);
597}
598
599void SurfaceInterceptor::addDisplayCreationLocked(Increment* increment,
600 const DisplayDeviceState& info)
601{
602 DisplayCreation* creation(increment->mutable_display_creation());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700603 creation->set_id(info.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700604 creation->set_name(info.displayName);
Irvelffc9efc2016-07-27 15:16:37 -0700605 creation->set_is_secure(info.isSecure);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800606 if (info.physical) {
607 creation->set_display_id(info.physical->id.value);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700608 }
Irvelffc9efc2016-07-27 15:16:37 -0700609}
610
Dominik Laskowski663bd282018-04-19 15:26:54 -0700611void SurfaceInterceptor::addDisplayDeletionLocked(Increment* increment, int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700612 DisplayDeletion* deletion(increment->mutable_display_deletion());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700613 deletion->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700614}
615
Dominik Laskowski663bd282018-04-19 15:26:54 -0700616void SurfaceInterceptor::addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700617 int32_t mode)
618{
619 PowerModeUpdate* powerModeUpdate(increment->mutable_power_mode_update());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700620 powerModeUpdate->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700621 powerModeUpdate->set_mode(mode);
622}
623
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000624void SurfaceInterceptor::saveTransaction(
625 const Vector<ComposerState>& stateUpdates,
626 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000627 const Vector<DisplayState>& changedDisplays, uint32_t flags, int originPid, int originUid,
628 uint64_t transactionId) {
Irvelffc9efc2016-07-27 15:16:37 -0700629 if (!mEnabled || (stateUpdates.size() <= 0 && changedDisplays.size() <= 0)) {
630 return;
631 }
Irvelc274c632016-06-13 16:44:08 -0700632 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700633 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
634 addTransactionLocked(createTraceIncrementLocked(), stateUpdates, displays, changedDisplays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000635 flags, originPid, originUid, transactionId);
Irvelffc9efc2016-07-27 15:16:37 -0700636}
637
638void SurfaceInterceptor::saveSurfaceCreation(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700639 if (!mEnabled || layer == nullptr) {
640 return;
641 }
Irvelc274c632016-06-13 16:44:08 -0700642 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700643 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
644 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
645}
646
647void SurfaceInterceptor::saveSurfaceDeletion(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700648 if (!mEnabled || layer == nullptr) {
649 return;
650 }
Irvelffc9efc2016-07-27 15:16:37 -0700651 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700652 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700653 addSurfaceDeletionLocked(createTraceIncrementLocked(), layer);
Irvelc274c632016-06-13 16:44:08 -0700654}
655
Rob Carra79435b2020-03-06 14:46:07 -0800656/**
657 * Here we pass the layer by ID instead of by sp<> since this is called without
658 * holding the state-lock from a Binder thread. If we required the caller
659 * to pass 'this' by sp<> the temporary sp<> constructed could end up
660 * being the last reference and we might accidentally destroy the Layer
661 * from this binder thread.
662 */
663void SurfaceInterceptor::saveBufferUpdate(int32_t layerId, uint32_t width,
Irvelc274c632016-06-13 16:44:08 -0700664 uint32_t height, uint64_t frameNumber)
665{
Rob Carra79435b2020-03-06 14:46:07 -0800666 if (!mEnabled) {
Irvelc274c632016-06-13 16:44:08 -0700667 return;
668 }
Irvelffc9efc2016-07-27 15:16:37 -0700669 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700670 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Rob Carra79435b2020-03-06 14:46:07 -0800671 addBufferUpdateLocked(createTraceIncrementLocked(), layerId, width, height, frameNumber);
Irvelc274c632016-06-13 16:44:08 -0700672}
673
674void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
675 if (!mEnabled) {
676 return;
677 }
678 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700679 addVSyncUpdateLocked(createTraceIncrementLocked(), timestamp);
Irvelc274c632016-06-13 16:44:08 -0700680}
681
Irvelffc9efc2016-07-27 15:16:37 -0700682void SurfaceInterceptor::saveDisplayCreation(const DisplayDeviceState& info) {
683 if (!mEnabled) {
684 return;
685 }
686 ATRACE_CALL();
687 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
688 addDisplayCreationLocked(createTraceIncrementLocked(), info);
689}
690
Dominik Laskowski663bd282018-04-19 15:26:54 -0700691void SurfaceInterceptor::saveDisplayDeletion(int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700692 if (!mEnabled) {
693 return;
694 }
695 ATRACE_CALL();
696 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700697 addDisplayDeletionLocked(createTraceIncrementLocked(), sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700698}
699
Dominik Laskowski663bd282018-04-19 15:26:54 -0700700void SurfaceInterceptor::savePowerModeUpdate(int32_t sequenceId, int32_t mode) {
Irvelffc9efc2016-07-27 15:16:37 -0700701 if (!mEnabled) {
702 return;
703 }
704 ATRACE_CALL();
705 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700706 addPowerModeUpdateLocked(createTraceIncrementLocked(), sequenceId, mode);
Irvelffc9efc2016-07-27 15:16:37 -0700707}
708
Lloyd Pique4dccc412018-01-22 17:21:36 -0800709} // namespace impl
Irvelc274c632016-06-13 16:44:08 -0700710} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -0800711
712// TODO(b/129481165): remove the #pragma below and fix conversion issues
713#pragma clang diagnostic pop // ignored "-Wconversion"