blob: 6f1a0f63e45c561b76dbd9901343c8fa9c937d9e [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
49 asBinder->linkToDeath(this);
50
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) {
Robert Carr1f0a16a2016-10-24 16:27:39 -0700118 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
119 addInitialSurfaceStateLocked(createTraceIncrementLocked(), layer);
120 });
Irvelc274c632016-06-13 16:44:08 -0700121 }
Irvelffc9efc2016-07-27 15:16:37 -0700122}
123
124void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment,
125 const sp<const Layer>& layer)
126{
Irvelc274c632016-06-13 16:44:08 -0700127 Transaction* transaction(increment->mutable_transaction());
Lloyd Piquef1c675b2018-09-12 20:45:39 -0700128 const uint32_t layerFlags = layer->getTransactionFlags();
129 transaction->set_synchronous(layerFlags & BnSurfaceComposer::eSynchronous);
130 transaction->set_animation(layerFlags & BnSurfaceComposer::eAnimation);
Irvelc274c632016-06-13 16:44:08 -0700131
132 const int32_t layerId(getLayerId(layer));
Robert Carr6a160312021-05-17 12:08:20 -0700133 addPositionLocked(transaction, layerId, layer->mDrawingState.transform.tx(),
134 layer->mDrawingState.transform.ty());
135 addDepthLocked(transaction, layerId, layer->mDrawingState.z);
136 addAlphaLocked(transaction, layerId, layer->mDrawingState.color.a);
Marissa Wallf58c14b2018-07-24 10:50:43 -0700137 addTransparentRegionLocked(transaction, layerId,
Robert Carr6a160312021-05-17 12:08:20 -0700138 layer->mDrawingState.activeTransparentRegion_legacy);
139 addLayerStackLocked(transaction, layerId, layer->mDrawingState.layerStack);
140 addCropLocked(transaction, layerId, layer->mDrawingState.crop);
141 addCornerRadiusLocked(transaction, layerId, layer->mDrawingState.cornerRadius);
142 addBackgroundBlurRadiusLocked(transaction, layerId, layer->mDrawingState.backgroundBlurRadius);
143 addBlurRegionsLocked(transaction, layerId, layer->mDrawingState.blurRegions);
144 addFlagsLocked(transaction, layerId, layer->mDrawingState.flags,
Vishnu Nair456bbb22019-07-18 16:02:00 -0700145 layer_state_t::eLayerHidden | layer_state_t::eLayerOpaque |
146 layer_state_t::eLayerSecure);
Robert Carr6a160312021-05-17 12:08:20 -0700147 addReparentLocked(transaction, layerId, getLayerIdFromWeakRef(layer->mDrawingParent));
Vishnu Nair456bbb22019-07-18 16:02:00 -0700148 addRelativeParentLocked(transaction, layerId,
Robert Carr6a160312021-05-17 12:08:20 -0700149 getLayerIdFromWeakRef(layer->mDrawingState.zOrderRelativeOf),
150 layer->mDrawingState.z);
151 addShadowRadiusLocked(transaction, layerId, layer->mDrawingState.shadowRadius);
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,
325 uint32_t layerStack)
326{
Irvelffc9efc2016-07-27 15:16:37 -0700327 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700328 LayerStackChange* layerStackChange(change->mutable_layer_stack());
329 layerStackChange->set_layer_stack(layerStack);
330}
331
332void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
333 const Rect& rect)
334{
Irvelffc9efc2016-07-27 15:16:37 -0700335 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700336 CropChange* cropChange(change->mutable_crop());
337 Rectangle* protoRect(cropChange->mutable_rectangle());
338 setProtoRectLocked(protoRect, rect);
339}
340
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700341void SurfaceInterceptor::addCornerRadiusLocked(Transaction* transaction, int32_t layerId,
342 float cornerRadius)
343{
344 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
345 CornerRadiusChange* cornerRadiusChange(change->mutable_corner_radius());
346 cornerRadiusChange->set_corner_radius(cornerRadius);
347}
348
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800349void SurfaceInterceptor::addBackgroundBlurRadiusLocked(Transaction* transaction, int32_t layerId,
350 int32_t backgroundBlurRadius) {
351 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
352 BackgroundBlurRadiusChange* blurRadiusChange(change->mutable_background_blur_radius());
353 blurRadiusChange->set_background_blur_radius(backgroundBlurRadius);
354}
355
Lucas Dupinc3800b82020-10-02 16:24:48 -0700356void SurfaceInterceptor::addBlurRegionsLocked(Transaction* transaction, int32_t layerId,
357 const std::vector<BlurRegion>& blurRegions) {
358 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
359 BlurRegionsChange* blurRegionsChange(change->mutable_blur_regions());
360 for (const auto blurRegion : blurRegions) {
361 const auto blurRegionChange = blurRegionsChange->add_blur_regions();
362 blurRegionChange->set_blur_radius(blurRegion.blurRadius);
363 blurRegionChange->set_corner_radius_tl(blurRegion.cornerRadiusTL);
364 blurRegionChange->set_corner_radius_tr(blurRegion.cornerRadiusTR);
365 blurRegionChange->set_corner_radius_bl(blurRegion.cornerRadiusBL);
366 blurRegionChange->set_corner_radius_br(blurRegion.cornerRadiusBR);
367 blurRegionChange->set_alpha(blurRegion.alpha);
368 blurRegionChange->set_left(blurRegion.left);
369 blurRegionChange->set_top(blurRegion.top);
370 blurRegionChange->set_right(blurRegion.right);
371 blurRegionChange->set_bottom(blurRegion.bottom);
372 }
373}
374
Vishnu Nair456bbb22019-07-18 16:02:00 -0700375void SurfaceInterceptor::addReparentLocked(Transaction* transaction, int32_t layerId,
376 int32_t parentId) {
377 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
378 ReparentChange* overrideChange(change->mutable_reparent());
379 overrideChange->set_parent_id(parentId);
380}
381
Vishnu Nair456bbb22019-07-18 16:02:00 -0700382void SurfaceInterceptor::addRelativeParentLocked(Transaction* transaction, int32_t layerId,
383 int32_t parentId, int z) {
384 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
385 RelativeParentChange* overrideChange(change->mutable_relative_parent());
386 overrideChange->set_relative_parent_id(parentId);
387 overrideChange->set_z(z);
388}
389
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800390void SurfaceInterceptor::addShadowRadiusLocked(Transaction* transaction, int32_t layerId,
391 float shadowRadius) {
392 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
393 ShadowRadiusChange* overrideChange(change->mutable_shadow_radius());
394 overrideChange->set_radius(shadowRadius);
395}
396
Irvelffc9efc2016-07-27 15:16:37 -0700397void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction,
Irvelc274c632016-06-13 16:44:08 -0700398 const layer_state_t& state)
399{
400 const sp<const Layer> layer(getLayer(state.surface));
401 if (layer == nullptr) {
402 ALOGE("An existing layer could not be retrieved with the surface "
403 "from the layer_state_t surface in the update transaction");
404 return;
405 }
406
407 const int32_t layerId(getLayerId(layer));
408
409 if (state.what & layer_state_t::ePositionChanged) {
410 addPositionLocked(transaction, layerId, state.x, state.y);
411 }
412 if (state.what & layer_state_t::eLayerChanged) {
413 addDepthLocked(transaction, layerId, state.z);
414 }
415 if (state.what & layer_state_t::eSizeChanged) {
416 addSizeLocked(transaction, layerId, state.w, state.h);
417 }
418 if (state.what & layer_state_t::eAlphaChanged) {
419 addAlphaLocked(transaction, layerId, state.alpha);
420 }
421 if (state.what & layer_state_t::eMatrixChanged) {
422 addMatrixLocked(transaction, layerId, state.matrix);
423 }
424 if (state.what & layer_state_t::eTransparentRegionChanged) {
425 addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
426 }
427 if (state.what & layer_state_t::eFlagsChanged) {
Vishnu Nair456bbb22019-07-18 16:02:00 -0700428 addFlagsLocked(transaction, layerId, state.flags, state.mask);
Irvelc274c632016-06-13 16:44:08 -0700429 }
430 if (state.what & layer_state_t::eLayerStackChanged) {
431 addLayerStackLocked(transaction, layerId, state.layerStack);
432 }
chaviw25714502021-02-11 10:01:08 -0800433 if (state.what & layer_state_t::eCropChanged) {
434 addCropLocked(transaction, layerId, state.crop);
Irvelc274c632016-06-13 16:44:08 -0700435 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700436 if (state.what & layer_state_t::eCornerRadiusChanged) {
437 addCornerRadiusLocked(transaction, layerId, state.cornerRadius);
438 }
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800439 if (state.what & layer_state_t::eBackgroundBlurRadiusChanged) {
440 addBackgroundBlurRadiusLocked(transaction, layerId, state.backgroundBlurRadius);
441 }
Lucas Dupinc3800b82020-10-02 16:24:48 -0700442 if (state.what & layer_state_t::eBlurRegionsChanged) {
443 addBlurRegionsLocked(transaction, layerId, state.blurRegions);
444 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700445 if (state.what & layer_state_t::eReparent) {
Pablo Gamito11dcc222020-09-12 15:49:39 +0000446 auto parentHandle = (state.parentSurfaceControlForChild)
447 ? state.parentSurfaceControlForChild->getHandle()
448 : nullptr;
449 addReparentLocked(transaction, layerId, getLayerIdFromHandle(parentHandle));
Vishnu Nair456bbb22019-07-18 16:02:00 -0700450 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700451 if (state.what & layer_state_t::eRelativeLayerChanged) {
452 addRelativeParentLocked(transaction, layerId,
Pablo Gamito11dcc222020-09-12 15:49:39 +0000453 getLayerIdFromHandle(
454 state.relativeLayerSurfaceControl->getHandle()),
455 state.z);
Vishnu Nair456bbb22019-07-18 16:02:00 -0700456 }
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800457 if (state.what & layer_state_t::eShadowRadiusChanged) {
458 addShadowRadiusLocked(transaction, layerId, state.shadowRadius);
459 }
John Reckc00c6692021-02-16 11:37:33 -0500460 if (state.what & layer_state_t::eStretchChanged) {
461 ALOGW("SurfaceInterceptor not implemented for eStretchChanged");
462 }
Irvelc274c632016-06-13 16:44:08 -0700463}
464
Irvelffc9efc2016-07-27 15:16:37 -0700465void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700466 const DisplayState& state, int32_t sequenceId)
Irvelc274c632016-06-13 16:44:08 -0700467{
Irvelffc9efc2016-07-27 15:16:37 -0700468 if (state.what & DisplayState::eSurfaceChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700469 addDisplaySurfaceLocked(transaction, sequenceId, state.surface);
Irvelffc9efc2016-07-27 15:16:37 -0700470 }
471 if (state.what & DisplayState::eLayerStackChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700472 addDisplayLayerStackLocked(transaction, sequenceId, state.layerStack);
Irvelffc9efc2016-07-27 15:16:37 -0700473 }
Evan Rosky2239b372021-05-20 13:43:47 -0700474 if (state.what & DisplayState::eFlagsChanged) {
475 addDisplayFlagsLocked(transaction, sequenceId, state.flags);
476 }
Irvelffc9efc2016-07-27 15:16:37 -0700477 if (state.what & DisplayState::eDisplaySizeChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700478 addDisplaySizeLocked(transaction, sequenceId, state.width, state.height);
Irvelffc9efc2016-07-27 15:16:37 -0700479 }
480 if (state.what & DisplayState::eDisplayProjectionChanged) {
Dominik Laskowski718f9602019-11-09 20:01:35 -0800481 addDisplayProjectionLocked(transaction, sequenceId, toRotationInt(state.orientation),
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200482 state.layerStackSpaceRect, state.orientedDisplaySpaceRect);
Irvelc274c632016-06-13 16:44:08 -0700483 }
484}
485
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000486void SurfaceInterceptor::addTransactionLocked(
487 Increment* increment, const Vector<ComposerState>& stateUpdates,
488 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000489 const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags, int originPid,
490 int originUid, uint64_t transactionId) {
Irvelffc9efc2016-07-27 15:16:37 -0700491 Transaction* transaction(increment->mutable_transaction());
492 transaction->set_synchronous(transactionFlags & BnSurfaceComposer::eSynchronous);
493 transaction->set_animation(transactionFlags & BnSurfaceComposer::eAnimation);
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000494 setTransactionOriginLocked(transaction, originPid, originUid);
495 transaction->set_id(transactionId);
Irvelffc9efc2016-07-27 15:16:37 -0700496 for (const auto& compState: stateUpdates) {
497 addSurfaceChangesLocked(transaction, compState.state);
498 }
499 for (const auto& disp: changedDisplays) {
500 ssize_t dpyIdx = displays.indexOfKey(disp.token);
501 if (dpyIdx >= 0) {
502 const DisplayDeviceState& dispState(displays.valueAt(dpyIdx));
Dominik Laskowski663bd282018-04-19 15:26:54 -0700503 addDisplayChangesLocked(transaction, disp, dispState.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700504 }
505 }
Irvelc274c632016-06-13 16:44:08 -0700506}
507
Irvelffc9efc2016-07-27 15:16:37 -0700508void SurfaceInterceptor::addSurfaceCreationLocked(Increment* increment,
509 const sp<const Layer>& layer)
510{
511 SurfaceCreation* creation(increment->mutable_surface_creation());
512 creation->set_id(getLayerId(layer));
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700513 creation->set_name(layer->getName());
Robert Carr6a160312021-05-17 12:08:20 -0700514 creation->set_w(layer->mDrawingState.active_legacy.w);
515 creation->set_h(layer->mDrawingState.active_legacy.h);
Irvelc274c632016-06-13 16:44:08 -0700516}
517
Irvelffc9efc2016-07-27 15:16:37 -0700518void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
519 const sp<const Layer>& layer)
520{
521 SurfaceDeletion* deletion(increment->mutable_surface_deletion());
522 deletion->set_id(getLayerId(layer));
523}
524
Rob Carra79435b2020-03-06 14:46:07 -0800525void SurfaceInterceptor::addBufferUpdateLocked(Increment* increment, int32_t layerId,
Irvelc274c632016-06-13 16:44:08 -0700526 uint32_t width, uint32_t height, uint64_t frameNumber)
527{
528 BufferUpdate* update(increment->mutable_buffer_update());
Rob Carra79435b2020-03-06 14:46:07 -0800529 update->set_id(layerId);
Irvelc274c632016-06-13 16:44:08 -0700530 update->set_w(width);
531 update->set_h(height);
532 update->set_frame_number(frameNumber);
533}
534
Irvelffc9efc2016-07-27 15:16:37 -0700535void SurfaceInterceptor::addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp) {
Irvelc274c632016-06-13 16:44:08 -0700536 VSyncEvent* event(increment->mutable_vsync_event());
537 event->set_when(timestamp);
538}
539
Dominik Laskowski663bd282018-04-19 15:26:54 -0700540void SurfaceInterceptor::addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700541 const sp<const IGraphicBufferProducer>& surface)
Irvelc274c632016-06-13 16:44:08 -0700542{
Irvelffc9efc2016-07-27 15:16:37 -0700543 if (surface == nullptr) {
Irvelc274c632016-06-13 16:44:08 -0700544 return;
545 }
Irvelffc9efc2016-07-27 15:16:37 -0700546 uint64_t bufferQueueId = 0;
547 status_t err(surface->getUniqueId(&bufferQueueId));
548 if (err == NO_ERROR) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700549 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700550 DispSurfaceChange* surfaceChange(dispChange->mutable_surface());
551 surfaceChange->set_buffer_queue_id(bufferQueueId);
552 surfaceChange->set_buffer_queue_name(surface->getConsumerName().string());
553 }
554 else {
555 ALOGE("invalid graphic buffer producer received while tracing a display change (%s)",
556 strerror(-err));
557 }
Irvelc274c632016-06-13 16:44:08 -0700558}
559
Irvelffc9efc2016-07-27 15:16:37 -0700560void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700561 int32_t sequenceId, uint32_t layerStack)
Irvelffc9efc2016-07-27 15:16:37 -0700562{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700563 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700564 LayerStackChange* layerStackChange(dispChange->mutable_layer_stack());
565 layerStackChange->set_layer_stack(layerStack);
566}
567
Evan Rosky2239b372021-05-20 13:43:47 -0700568void SurfaceInterceptor::addDisplayFlagsLocked(Transaction* transaction, int32_t sequenceId,
569 uint32_t flags) {
570 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
571 DisplayFlagsChange* flagsChange(dispChange->mutable_flags());
572 flagsChange->set_flags(flags);
573}
574
Dominik Laskowski663bd282018-04-19 15:26:54 -0700575void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700576 uint32_t w, uint32_t h)
577{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700578 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700579 SizeChange* sizeChange(dispChange->mutable_size());
580 sizeChange->set_w(w);
581 sizeChange->set_h(h);
582}
583
584void SurfaceInterceptor::addDisplayProjectionLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700585 int32_t sequenceId, int32_t orientation, const Rect& viewport, const Rect& frame)
Irvelffc9efc2016-07-27 15:16:37 -0700586{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700587 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700588 ProjectionChange* projectionChange(dispChange->mutable_projection());
589 projectionChange->set_orientation(orientation);
590 Rectangle* viewportRect(projectionChange->mutable_viewport());
591 setProtoRectLocked(viewportRect, viewport);
592 Rectangle* frameRect(projectionChange->mutable_frame());
593 setProtoRectLocked(frameRect, frame);
594}
595
596void SurfaceInterceptor::addDisplayCreationLocked(Increment* increment,
597 const DisplayDeviceState& info)
598{
599 DisplayCreation* creation(increment->mutable_display_creation());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700600 creation->set_id(info.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700601 creation->set_name(info.displayName);
Irvelffc9efc2016-07-27 15:16:37 -0700602 creation->set_is_secure(info.isSecure);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800603 if (info.physical) {
604 creation->set_display_id(info.physical->id.value);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700605 }
Irvelffc9efc2016-07-27 15:16:37 -0700606}
607
Dominik Laskowski663bd282018-04-19 15:26:54 -0700608void SurfaceInterceptor::addDisplayDeletionLocked(Increment* increment, int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700609 DisplayDeletion* deletion(increment->mutable_display_deletion());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700610 deletion->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700611}
612
Dominik Laskowski663bd282018-04-19 15:26:54 -0700613void SurfaceInterceptor::addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700614 int32_t mode)
615{
616 PowerModeUpdate* powerModeUpdate(increment->mutable_power_mode_update());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700617 powerModeUpdate->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700618 powerModeUpdate->set_mode(mode);
619}
620
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000621void SurfaceInterceptor::saveTransaction(
622 const Vector<ComposerState>& stateUpdates,
623 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000624 const Vector<DisplayState>& changedDisplays, uint32_t flags, int originPid, int originUid,
625 uint64_t transactionId) {
Irvelffc9efc2016-07-27 15:16:37 -0700626 if (!mEnabled || (stateUpdates.size() <= 0 && changedDisplays.size() <= 0)) {
627 return;
628 }
Irvelc274c632016-06-13 16:44:08 -0700629 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700630 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
631 addTransactionLocked(createTraceIncrementLocked(), stateUpdates, displays, changedDisplays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000632 flags, originPid, originUid, transactionId);
Irvelffc9efc2016-07-27 15:16:37 -0700633}
634
635void SurfaceInterceptor::saveSurfaceCreation(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700636 if (!mEnabled || layer == nullptr) {
637 return;
638 }
Irvelc274c632016-06-13 16:44:08 -0700639 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700640 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
641 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
642}
643
644void SurfaceInterceptor::saveSurfaceDeletion(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700645 if (!mEnabled || layer == nullptr) {
646 return;
647 }
Irvelffc9efc2016-07-27 15:16:37 -0700648 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700649 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700650 addSurfaceDeletionLocked(createTraceIncrementLocked(), layer);
Irvelc274c632016-06-13 16:44:08 -0700651}
652
Rob Carra79435b2020-03-06 14:46:07 -0800653/**
654 * Here we pass the layer by ID instead of by sp<> since this is called without
655 * holding the state-lock from a Binder thread. If we required the caller
656 * to pass 'this' by sp<> the temporary sp<> constructed could end up
657 * being the last reference and we might accidentally destroy the Layer
658 * from this binder thread.
659 */
660void SurfaceInterceptor::saveBufferUpdate(int32_t layerId, uint32_t width,
Irvelc274c632016-06-13 16:44:08 -0700661 uint32_t height, uint64_t frameNumber)
662{
Rob Carra79435b2020-03-06 14:46:07 -0800663 if (!mEnabled) {
Irvelc274c632016-06-13 16:44:08 -0700664 return;
665 }
Irvelffc9efc2016-07-27 15:16:37 -0700666 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700667 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Rob Carra79435b2020-03-06 14:46:07 -0800668 addBufferUpdateLocked(createTraceIncrementLocked(), layerId, width, height, frameNumber);
Irvelc274c632016-06-13 16:44:08 -0700669}
670
671void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
672 if (!mEnabled) {
673 return;
674 }
675 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700676 addVSyncUpdateLocked(createTraceIncrementLocked(), timestamp);
Irvelc274c632016-06-13 16:44:08 -0700677}
678
Irvelffc9efc2016-07-27 15:16:37 -0700679void SurfaceInterceptor::saveDisplayCreation(const DisplayDeviceState& info) {
680 if (!mEnabled) {
681 return;
682 }
683 ATRACE_CALL();
684 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
685 addDisplayCreationLocked(createTraceIncrementLocked(), info);
686}
687
Dominik Laskowski663bd282018-04-19 15:26:54 -0700688void SurfaceInterceptor::saveDisplayDeletion(int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700689 if (!mEnabled) {
690 return;
691 }
692 ATRACE_CALL();
693 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700694 addDisplayDeletionLocked(createTraceIncrementLocked(), sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700695}
696
Dominik Laskowski663bd282018-04-19 15:26:54 -0700697void SurfaceInterceptor::savePowerModeUpdate(int32_t sequenceId, int32_t mode) {
Irvelffc9efc2016-07-27 15:16:37 -0700698 if (!mEnabled) {
699 return;
700 }
701 ATRACE_CALL();
702 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700703 addPowerModeUpdateLocked(createTraceIncrementLocked(), sequenceId, mode);
Irvelffc9efc2016-07-27 15:16:37 -0700704}
705
Lloyd Pique4dccc412018-01-22 17:21:36 -0800706} // namespace impl
Irvelc274c632016-06-13 16:44:08 -0700707} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -0800708
709// TODO(b/129481165): remove the #pragma below and fix conversion issues
710#pragma clang diagnostic pop // ignored "-Wconversion"