blob: 1f08a1db8b0a9bf33aedadff2b555ad23b45ed3e [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);
Winson Chunga30f7c92021-06-29 15:42:56 -0700152 addTrustedOverlayLocked(transaction, layerId, layer->mDrawingState.isTrustedOverlay);
Irvelc274c632016-06-13 16:44:08 -0700153}
154
Irvelffc9efc2016-07-27 15:16:37 -0700155void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment,
156 const DisplayDeviceState& display)
157{
158 Transaction* transaction(increment->mutable_transaction());
159 transaction->set_synchronous(false);
160 transaction->set_animation(false);
161
Dominik Laskowski663bd282018-04-19 15:26:54 -0700162 addDisplaySurfaceLocked(transaction, display.sequenceId, display.surface);
163 addDisplayLayerStackLocked(transaction, display.sequenceId, display.layerStack);
Evan Rosky2239b372021-05-20 13:43:47 -0700164 addDisplayFlagsLocked(transaction, display.sequenceId, display.flags);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700165 addDisplaySizeLocked(transaction, display.sequenceId, display.width, display.height);
Dominik Laskowski718f9602019-11-09 20:01:35 -0800166 addDisplayProjectionLocked(transaction, display.sequenceId, toRotationInt(display.orientation),
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200167 display.layerStackSpaceRect, display.orientedDisplaySpaceRect);
Irvelffc9efc2016-07-27 15:16:37 -0700168}
169
Irvelc274c632016-06-13 16:44:08 -0700170status_t SurfaceInterceptor::writeProtoFileLocked() {
171 ATRACE_CALL();
Colin Cross63549382016-10-26 12:52:53 -0700172 std::string output;
173
Irvelc274c632016-06-13 16:44:08 -0700174 if (!mTrace.IsInitialized()) {
175 return NOT_ENOUGH_DATA;
176 }
Colin Cross63549382016-10-26 12:52:53 -0700177 if (!mTrace.SerializeToString(&output)) {
Irvelc274c632016-06-13 16:44:08 -0700178 return PERMISSION_DENIED;
179 }
Colin Cross63549382016-10-26 12:52:53 -0700180 if (!android::base::WriteStringToFile(output, mOutputFileName, true)) {
181 return PERMISSION_DENIED;
182 }
183
Irvelc274c632016-06-13 16:44:08 -0700184 return NO_ERROR;
185}
186
Vishnu Nair456bbb22019-07-18 16:02:00 -0700187const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) const {
Irvel3017c612016-08-09 16:50:06 -0700188 const sp<const IBinder>& handle(weakHandle.promote());
Irvelc274c632016-06-13 16:44:08 -0700189 const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
190 const sp<const Layer> layer(layerHandle->owner.promote());
191 // layer could be a nullptr at this point
192 return layer;
193}
194
Vishnu Nair456bbb22019-07-18 16:02:00 -0700195int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) const {
Irvelc274c632016-06-13 16:44:08 -0700196 return layer->sequence;
197}
198
Vishnu Nair456bbb22019-07-18 16:02:00 -0700199int32_t SurfaceInterceptor::getLayerIdFromWeakRef(const wp<const Layer>& layer) const {
200 if (layer == nullptr) {
201 return -1;
202 }
203 auto strongLayer = layer.promote();
204 return strongLayer == nullptr ? -1 : getLayerId(strongLayer);
205}
206
207int32_t SurfaceInterceptor::getLayerIdFromHandle(const sp<const IBinder>& handle) const {
208 if (handle == nullptr) {
209 return -1;
210 }
211 const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
212 const sp<const Layer> layer(layerHandle->owner.promote());
213 return layer == nullptr ? -1 : getLayerId(layer);
214}
215
Irvelffc9efc2016-07-27 15:16:37 -0700216Increment* SurfaceInterceptor::createTraceIncrementLocked() {
Irvelc274c632016-06-13 16:44:08 -0700217 Increment* increment(mTrace.add_increment());
Vishnu Nair45cb21a2020-03-27 17:39:24 -0700218 increment->set_time_stamp(elapsedRealtimeNano());
Irvelc274c632016-06-13 16:44:08 -0700219 return increment;
220}
221
Irvelffc9efc2016-07-27 15:16:37 -0700222SurfaceChange* SurfaceInterceptor::createSurfaceChangeLocked(Transaction* transaction,
223 int32_t layerId)
224{
225 SurfaceChange* change(transaction->add_surface_change());
Irvelc274c632016-06-13 16:44:08 -0700226 change->set_id(layerId);
227 return change;
228}
229
Irvelffc9efc2016-07-27 15:16:37 -0700230DisplayChange* SurfaceInterceptor::createDisplayChangeLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700231 int32_t sequenceId)
Irvelffc9efc2016-07-27 15:16:37 -0700232{
233 DisplayChange* dispChange(transaction->add_display_change());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700234 dispChange->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700235 return dispChange;
236}
237
Irvelc274c632016-06-13 16:44:08 -0700238void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) {
239 protoRect->set_left(rect.left);
240 protoRect->set_top(rect.top);
241 protoRect->set_right(rect.right);
242 protoRect->set_bottom(rect.bottom);
243}
244
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000245void SurfaceInterceptor::setTransactionOriginLocked(Transaction* transaction, int32_t pid,
246 int32_t uid) {
247 Origin* origin(transaction->mutable_origin());
248 origin->set_pid(pid);
249 origin->set_uid(uid);
250}
251
Irvelffc9efc2016-07-27 15:16:37 -0700252void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId,
253 float x, float y)
Irvelc274c632016-06-13 16:44:08 -0700254{
Irvelffc9efc2016-07-27 15:16:37 -0700255 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700256 PositionChange* posChange(change->mutable_position());
257 posChange->set_x(x);
258 posChange->set_y(y);
259}
260
Irvelffc9efc2016-07-27 15:16:37 -0700261void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId,
262 uint32_t z)
263{
264 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700265 LayerChange* depthChange(change->mutable_layer());
266 depthChange->set_layer(z);
267}
268
269void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w,
270 uint32_t h)
271{
Irvelffc9efc2016-07-27 15:16:37 -0700272 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700273 SizeChange* sizeChange(change->mutable_size());
274 sizeChange->set_w(w);
275 sizeChange->set_h(h);
276}
277
Irvelffc9efc2016-07-27 15:16:37 -0700278void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId,
279 float alpha)
280{
281 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700282 AlphaChange* alphaChange(change->mutable_alpha());
283 alphaChange->set_alpha(alpha);
284}
285
286void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId,
287 const layer_state_t::matrix22_t& matrix)
288{
Irvelffc9efc2016-07-27 15:16:37 -0700289 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700290 MatrixChange* matrixChange(change->mutable_matrix());
291 matrixChange->set_dsdx(matrix.dsdx);
292 matrixChange->set_dtdx(matrix.dtdx);
293 matrixChange->set_dsdy(matrix.dsdy);
294 matrixChange->set_dtdy(matrix.dtdy);
295}
296
Irvelffc9efc2016-07-27 15:16:37 -0700297void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction,
298 int32_t layerId, const Region& transRegion)
Irvelc274c632016-06-13 16:44:08 -0700299{
Irvelffc9efc2016-07-27 15:16:37 -0700300 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700301 TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint());
302
303 for (const auto& rect : transRegion) {
304 Rectangle* protoRect(transparentChange->add_region());
305 setProtoRectLocked(protoRect, rect);
306 }
307}
308
Vishnu Nair456bbb22019-07-18 16:02:00 -0700309void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags,
310 uint8_t mask) {
Irvelc274c632016-06-13 16:44:08 -0700311 // There can be multiple flags changed
Vishnu Nair456bbb22019-07-18 16:02:00 -0700312 if (mask & layer_state_t::eLayerHidden) {
Irvelffc9efc2016-07-27 15:16:37 -0700313 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700314 HiddenFlagChange* flagChange(change->mutable_hidden_flag());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700315 flagChange->set_hidden_flag(flags & layer_state_t::eLayerHidden);
Irvelc274c632016-06-13 16:44:08 -0700316 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700317 if (mask & layer_state_t::eLayerOpaque) {
Irvelffc9efc2016-07-27 15:16:37 -0700318 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700319 OpaqueFlagChange* flagChange(change->mutable_opaque_flag());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700320 flagChange->set_opaque_flag(flags & layer_state_t::eLayerOpaque);
Irvelc274c632016-06-13 16:44:08 -0700321 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700322 if (mask & layer_state_t::eLayerSecure) {
Irvelffc9efc2016-07-27 15:16:37 -0700323 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700324 SecureFlagChange* flagChange(change->mutable_secure_flag());
Vishnu Nair456bbb22019-07-18 16:02:00 -0700325 flagChange->set_secure_flag(flags & layer_state_t::eLayerSecure);
Irvelc274c632016-06-13 16:44:08 -0700326 }
327}
328
329void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId,
330 uint32_t layerStack)
331{
Irvelffc9efc2016-07-27 15:16:37 -0700332 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700333 LayerStackChange* layerStackChange(change->mutable_layer_stack());
334 layerStackChange->set_layer_stack(layerStack);
335}
336
337void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
338 const Rect& rect)
339{
Irvelffc9efc2016-07-27 15:16:37 -0700340 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700341 CropChange* cropChange(change->mutable_crop());
342 Rectangle* protoRect(cropChange->mutable_rectangle());
343 setProtoRectLocked(protoRect, rect);
344}
345
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700346void SurfaceInterceptor::addCornerRadiusLocked(Transaction* transaction, int32_t layerId,
347 float cornerRadius)
348{
349 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
350 CornerRadiusChange* cornerRadiusChange(change->mutable_corner_radius());
351 cornerRadiusChange->set_corner_radius(cornerRadius);
352}
353
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800354void SurfaceInterceptor::addBackgroundBlurRadiusLocked(Transaction* transaction, int32_t layerId,
355 int32_t backgroundBlurRadius) {
356 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
357 BackgroundBlurRadiusChange* blurRadiusChange(change->mutable_background_blur_radius());
358 blurRadiusChange->set_background_blur_radius(backgroundBlurRadius);
359}
360
Lucas Dupinc3800b82020-10-02 16:24:48 -0700361void SurfaceInterceptor::addBlurRegionsLocked(Transaction* transaction, int32_t layerId,
362 const std::vector<BlurRegion>& blurRegions) {
363 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
364 BlurRegionsChange* blurRegionsChange(change->mutable_blur_regions());
365 for (const auto blurRegion : blurRegions) {
366 const auto blurRegionChange = blurRegionsChange->add_blur_regions();
367 blurRegionChange->set_blur_radius(blurRegion.blurRadius);
368 blurRegionChange->set_corner_radius_tl(blurRegion.cornerRadiusTL);
369 blurRegionChange->set_corner_radius_tr(blurRegion.cornerRadiusTR);
370 blurRegionChange->set_corner_radius_bl(blurRegion.cornerRadiusBL);
371 blurRegionChange->set_corner_radius_br(blurRegion.cornerRadiusBR);
372 blurRegionChange->set_alpha(blurRegion.alpha);
373 blurRegionChange->set_left(blurRegion.left);
374 blurRegionChange->set_top(blurRegion.top);
375 blurRegionChange->set_right(blurRegion.right);
376 blurRegionChange->set_bottom(blurRegion.bottom);
377 }
378}
379
Vishnu Nair456bbb22019-07-18 16:02:00 -0700380void SurfaceInterceptor::addReparentLocked(Transaction* transaction, int32_t layerId,
381 int32_t parentId) {
382 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
383 ReparentChange* overrideChange(change->mutable_reparent());
384 overrideChange->set_parent_id(parentId);
385}
386
Vishnu Nair456bbb22019-07-18 16:02:00 -0700387void SurfaceInterceptor::addRelativeParentLocked(Transaction* transaction, int32_t layerId,
388 int32_t parentId, int z) {
389 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
390 RelativeParentChange* overrideChange(change->mutable_relative_parent());
391 overrideChange->set_relative_parent_id(parentId);
392 overrideChange->set_z(z);
393}
394
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800395void SurfaceInterceptor::addShadowRadiusLocked(Transaction* transaction, int32_t layerId,
396 float shadowRadius) {
397 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
398 ShadowRadiusChange* overrideChange(change->mutable_shadow_radius());
399 overrideChange->set_radius(shadowRadius);
400}
401
Winson Chunga30f7c92021-06-29 15:42:56 -0700402void SurfaceInterceptor::addTrustedOverlayLocked(Transaction* transaction, int32_t layerId,
403 bool isTrustedOverlay) {
404 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
405 TrustedOverlayChange* overrideChange(change->mutable_trusted_overlay());
406 overrideChange->set_is_trusted_overlay(isTrustedOverlay);
407}
408
Irvelffc9efc2016-07-27 15:16:37 -0700409void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction,
Irvelc274c632016-06-13 16:44:08 -0700410 const layer_state_t& state)
411{
412 const sp<const Layer> layer(getLayer(state.surface));
413 if (layer == nullptr) {
414 ALOGE("An existing layer could not be retrieved with the surface "
415 "from the layer_state_t surface in the update transaction");
416 return;
417 }
418
419 const int32_t layerId(getLayerId(layer));
420
421 if (state.what & layer_state_t::ePositionChanged) {
422 addPositionLocked(transaction, layerId, state.x, state.y);
423 }
424 if (state.what & layer_state_t::eLayerChanged) {
425 addDepthLocked(transaction, layerId, state.z);
426 }
427 if (state.what & layer_state_t::eSizeChanged) {
428 addSizeLocked(transaction, layerId, state.w, state.h);
429 }
430 if (state.what & layer_state_t::eAlphaChanged) {
431 addAlphaLocked(transaction, layerId, state.alpha);
432 }
433 if (state.what & layer_state_t::eMatrixChanged) {
434 addMatrixLocked(transaction, layerId, state.matrix);
435 }
436 if (state.what & layer_state_t::eTransparentRegionChanged) {
437 addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
438 }
439 if (state.what & layer_state_t::eFlagsChanged) {
Vishnu Nair456bbb22019-07-18 16:02:00 -0700440 addFlagsLocked(transaction, layerId, state.flags, state.mask);
Irvelc274c632016-06-13 16:44:08 -0700441 }
442 if (state.what & layer_state_t::eLayerStackChanged) {
443 addLayerStackLocked(transaction, layerId, state.layerStack);
444 }
chaviw25714502021-02-11 10:01:08 -0800445 if (state.what & layer_state_t::eCropChanged) {
446 addCropLocked(transaction, layerId, state.crop);
Irvelc274c632016-06-13 16:44:08 -0700447 }
Lucas Dupin1b6531c2018-07-05 17:18:21 -0700448 if (state.what & layer_state_t::eCornerRadiusChanged) {
449 addCornerRadiusLocked(transaction, layerId, state.cornerRadius);
450 }
Lucas Dupin19c8f0e2019-11-25 17:55:44 -0800451 if (state.what & layer_state_t::eBackgroundBlurRadiusChanged) {
452 addBackgroundBlurRadiusLocked(transaction, layerId, state.backgroundBlurRadius);
453 }
Lucas Dupinc3800b82020-10-02 16:24:48 -0700454 if (state.what & layer_state_t::eBlurRegionsChanged) {
455 addBlurRegionsLocked(transaction, layerId, state.blurRegions);
456 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700457 if (state.what & layer_state_t::eReparent) {
Pablo Gamito11dcc222020-09-12 15:49:39 +0000458 auto parentHandle = (state.parentSurfaceControlForChild)
459 ? state.parentSurfaceControlForChild->getHandle()
460 : nullptr;
461 addReparentLocked(transaction, layerId, getLayerIdFromHandle(parentHandle));
Vishnu Nair456bbb22019-07-18 16:02:00 -0700462 }
Vishnu Nair456bbb22019-07-18 16:02:00 -0700463 if (state.what & layer_state_t::eRelativeLayerChanged) {
464 addRelativeParentLocked(transaction, layerId,
Pablo Gamito11dcc222020-09-12 15:49:39 +0000465 getLayerIdFromHandle(
466 state.relativeLayerSurfaceControl->getHandle()),
467 state.z);
Vishnu Nair456bbb22019-07-18 16:02:00 -0700468 }
Vishnu Nair95a1ed42019-12-06 12:25:11 -0800469 if (state.what & layer_state_t::eShadowRadiusChanged) {
470 addShadowRadiusLocked(transaction, layerId, state.shadowRadius);
471 }
Winson Chunga30f7c92021-06-29 15:42:56 -0700472 if (state.what & layer_state_t::eTrustedOverlayChanged) {
473 addTrustedOverlayLocked(transaction, layerId, state.isTrustedOverlay);
474 }
John Reckc00c6692021-02-16 11:37:33 -0500475 if (state.what & layer_state_t::eStretchChanged) {
476 ALOGW("SurfaceInterceptor not implemented for eStretchChanged");
477 }
Irvelc274c632016-06-13 16:44:08 -0700478}
479
Irvelffc9efc2016-07-27 15:16:37 -0700480void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700481 const DisplayState& state, int32_t sequenceId)
Irvelc274c632016-06-13 16:44:08 -0700482{
Irvelffc9efc2016-07-27 15:16:37 -0700483 if (state.what & DisplayState::eSurfaceChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700484 addDisplaySurfaceLocked(transaction, sequenceId, state.surface);
Irvelffc9efc2016-07-27 15:16:37 -0700485 }
486 if (state.what & DisplayState::eLayerStackChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700487 addDisplayLayerStackLocked(transaction, sequenceId, state.layerStack);
Irvelffc9efc2016-07-27 15:16:37 -0700488 }
Evan Rosky2239b372021-05-20 13:43:47 -0700489 if (state.what & DisplayState::eFlagsChanged) {
490 addDisplayFlagsLocked(transaction, sequenceId, state.flags);
491 }
Irvelffc9efc2016-07-27 15:16:37 -0700492 if (state.what & DisplayState::eDisplaySizeChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700493 addDisplaySizeLocked(transaction, sequenceId, state.width, state.height);
Irvelffc9efc2016-07-27 15:16:37 -0700494 }
495 if (state.what & DisplayState::eDisplayProjectionChanged) {
Dominik Laskowski718f9602019-11-09 20:01:35 -0800496 addDisplayProjectionLocked(transaction, sequenceId, toRotationInt(state.orientation),
Marin Shalamanov6ad317c2020-07-29 23:34:07 +0200497 state.layerStackSpaceRect, state.orientedDisplaySpaceRect);
Irvelc274c632016-06-13 16:44:08 -0700498 }
499}
500
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000501void SurfaceInterceptor::addTransactionLocked(
502 Increment* increment, const Vector<ComposerState>& stateUpdates,
503 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000504 const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags, int originPid,
505 int originUid, uint64_t transactionId) {
Irvelffc9efc2016-07-27 15:16:37 -0700506 Transaction* transaction(increment->mutable_transaction());
507 transaction->set_synchronous(transactionFlags & BnSurfaceComposer::eSynchronous);
508 transaction->set_animation(transactionFlags & BnSurfaceComposer::eAnimation);
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000509 setTransactionOriginLocked(transaction, originPid, originUid);
510 transaction->set_id(transactionId);
Irvelffc9efc2016-07-27 15:16:37 -0700511 for (const auto& compState: stateUpdates) {
512 addSurfaceChangesLocked(transaction, compState.state);
513 }
514 for (const auto& disp: changedDisplays) {
515 ssize_t dpyIdx = displays.indexOfKey(disp.token);
516 if (dpyIdx >= 0) {
517 const DisplayDeviceState& dispState(displays.valueAt(dpyIdx));
Dominik Laskowski663bd282018-04-19 15:26:54 -0700518 addDisplayChangesLocked(transaction, disp, dispState.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700519 }
520 }
Irvelc274c632016-06-13 16:44:08 -0700521}
522
Irvelffc9efc2016-07-27 15:16:37 -0700523void SurfaceInterceptor::addSurfaceCreationLocked(Increment* increment,
524 const sp<const Layer>& layer)
525{
526 SurfaceCreation* creation(increment->mutable_surface_creation());
527 creation->set_id(getLayerId(layer));
Dominik Laskowski87a07e42019-10-10 20:38:02 -0700528 creation->set_name(layer->getName());
Robert Carr6a160312021-05-17 12:08:20 -0700529 creation->set_w(layer->mDrawingState.active_legacy.w);
530 creation->set_h(layer->mDrawingState.active_legacy.h);
Irvelc274c632016-06-13 16:44:08 -0700531}
532
Irvelffc9efc2016-07-27 15:16:37 -0700533void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
534 const sp<const Layer>& layer)
535{
536 SurfaceDeletion* deletion(increment->mutable_surface_deletion());
537 deletion->set_id(getLayerId(layer));
538}
539
Rob Carra79435b2020-03-06 14:46:07 -0800540void SurfaceInterceptor::addBufferUpdateLocked(Increment* increment, int32_t layerId,
Irvelc274c632016-06-13 16:44:08 -0700541 uint32_t width, uint32_t height, uint64_t frameNumber)
542{
543 BufferUpdate* update(increment->mutable_buffer_update());
Rob Carra79435b2020-03-06 14:46:07 -0800544 update->set_id(layerId);
Irvelc274c632016-06-13 16:44:08 -0700545 update->set_w(width);
546 update->set_h(height);
547 update->set_frame_number(frameNumber);
548}
549
Irvelffc9efc2016-07-27 15:16:37 -0700550void SurfaceInterceptor::addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp) {
Irvelc274c632016-06-13 16:44:08 -0700551 VSyncEvent* event(increment->mutable_vsync_event());
552 event->set_when(timestamp);
553}
554
Dominik Laskowski663bd282018-04-19 15:26:54 -0700555void SurfaceInterceptor::addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700556 const sp<const IGraphicBufferProducer>& surface)
Irvelc274c632016-06-13 16:44:08 -0700557{
Irvelffc9efc2016-07-27 15:16:37 -0700558 if (surface == nullptr) {
Irvelc274c632016-06-13 16:44:08 -0700559 return;
560 }
Irvelffc9efc2016-07-27 15:16:37 -0700561 uint64_t bufferQueueId = 0;
562 status_t err(surface->getUniqueId(&bufferQueueId));
563 if (err == NO_ERROR) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700564 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700565 DispSurfaceChange* surfaceChange(dispChange->mutable_surface());
566 surfaceChange->set_buffer_queue_id(bufferQueueId);
567 surfaceChange->set_buffer_queue_name(surface->getConsumerName().string());
568 }
569 else {
570 ALOGE("invalid graphic buffer producer received while tracing a display change (%s)",
571 strerror(-err));
572 }
Irvelc274c632016-06-13 16:44:08 -0700573}
574
Irvelffc9efc2016-07-27 15:16:37 -0700575void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700576 int32_t sequenceId, uint32_t layerStack)
Irvelffc9efc2016-07-27 15:16:37 -0700577{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700578 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700579 LayerStackChange* layerStackChange(dispChange->mutable_layer_stack());
580 layerStackChange->set_layer_stack(layerStack);
581}
582
Evan Rosky2239b372021-05-20 13:43:47 -0700583void SurfaceInterceptor::addDisplayFlagsLocked(Transaction* transaction, int32_t sequenceId,
584 uint32_t flags) {
585 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
586 DisplayFlagsChange* flagsChange(dispChange->mutable_flags());
587 flagsChange->set_flags(flags);
588}
589
Dominik Laskowski663bd282018-04-19 15:26:54 -0700590void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700591 uint32_t w, uint32_t h)
592{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700593 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700594 SizeChange* sizeChange(dispChange->mutable_size());
595 sizeChange->set_w(w);
596 sizeChange->set_h(h);
597}
598
599void SurfaceInterceptor::addDisplayProjectionLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700600 int32_t sequenceId, int32_t orientation, const Rect& viewport, const Rect& frame)
Irvelffc9efc2016-07-27 15:16:37 -0700601{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700602 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700603 ProjectionChange* projectionChange(dispChange->mutable_projection());
604 projectionChange->set_orientation(orientation);
605 Rectangle* viewportRect(projectionChange->mutable_viewport());
606 setProtoRectLocked(viewportRect, viewport);
607 Rectangle* frameRect(projectionChange->mutable_frame());
608 setProtoRectLocked(frameRect, frame);
609}
610
611void SurfaceInterceptor::addDisplayCreationLocked(Increment* increment,
612 const DisplayDeviceState& info)
613{
614 DisplayCreation* creation(increment->mutable_display_creation());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700615 creation->set_id(info.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700616 creation->set_name(info.displayName);
Irvelffc9efc2016-07-27 15:16:37 -0700617 creation->set_is_secure(info.isSecure);
Dominik Laskowski55c85402020-01-21 16:25:47 -0800618 if (info.physical) {
619 creation->set_display_id(info.physical->id.value);
Dominik Laskowski075d3172018-05-24 15:50:06 -0700620 }
Irvelffc9efc2016-07-27 15:16:37 -0700621}
622
Dominik Laskowski663bd282018-04-19 15:26:54 -0700623void SurfaceInterceptor::addDisplayDeletionLocked(Increment* increment, int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700624 DisplayDeletion* deletion(increment->mutable_display_deletion());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700625 deletion->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700626}
627
Dominik Laskowski663bd282018-04-19 15:26:54 -0700628void SurfaceInterceptor::addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700629 int32_t mode)
630{
631 PowerModeUpdate* powerModeUpdate(increment->mutable_power_mode_update());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700632 powerModeUpdate->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700633 powerModeUpdate->set_mode(mode);
634}
635
Pablo Gamito3e8f0e62020-06-22 15:55:39 +0000636void SurfaceInterceptor::saveTransaction(
637 const Vector<ComposerState>& stateUpdates,
638 const DefaultKeyedVector<wp<IBinder>, DisplayDeviceState>& displays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000639 const Vector<DisplayState>& changedDisplays, uint32_t flags, int originPid, int originUid,
640 uint64_t transactionId) {
Irvelffc9efc2016-07-27 15:16:37 -0700641 if (!mEnabled || (stateUpdates.size() <= 0 && changedDisplays.size() <= 0)) {
642 return;
643 }
Irvelc274c632016-06-13 16:44:08 -0700644 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700645 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
646 addTransactionLocked(createTraceIncrementLocked(), stateUpdates, displays, changedDisplays,
Pablo Gamito7eb7ee72020-08-05 10:57:05 +0000647 flags, originPid, originUid, transactionId);
Irvelffc9efc2016-07-27 15:16:37 -0700648}
649
650void SurfaceInterceptor::saveSurfaceCreation(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700651 if (!mEnabled || layer == nullptr) {
652 return;
653 }
Irvelc274c632016-06-13 16:44:08 -0700654 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700655 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
656 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
657}
658
659void SurfaceInterceptor::saveSurfaceDeletion(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700660 if (!mEnabled || layer == nullptr) {
661 return;
662 }
Irvelffc9efc2016-07-27 15:16:37 -0700663 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700664 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700665 addSurfaceDeletionLocked(createTraceIncrementLocked(), layer);
Irvelc274c632016-06-13 16:44:08 -0700666}
667
Rob Carra79435b2020-03-06 14:46:07 -0800668/**
669 * Here we pass the layer by ID instead of by sp<> since this is called without
670 * holding the state-lock from a Binder thread. If we required the caller
671 * to pass 'this' by sp<> the temporary sp<> constructed could end up
672 * being the last reference and we might accidentally destroy the Layer
673 * from this binder thread.
674 */
675void SurfaceInterceptor::saveBufferUpdate(int32_t layerId, uint32_t width,
Irvelc274c632016-06-13 16:44:08 -0700676 uint32_t height, uint64_t frameNumber)
677{
Rob Carra79435b2020-03-06 14:46:07 -0800678 if (!mEnabled) {
Irvelc274c632016-06-13 16:44:08 -0700679 return;
680 }
Irvelffc9efc2016-07-27 15:16:37 -0700681 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700682 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Rob Carra79435b2020-03-06 14:46:07 -0800683 addBufferUpdateLocked(createTraceIncrementLocked(), layerId, width, height, frameNumber);
Irvelc274c632016-06-13 16:44:08 -0700684}
685
686void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
687 if (!mEnabled) {
688 return;
689 }
690 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700691 addVSyncUpdateLocked(createTraceIncrementLocked(), timestamp);
Irvelc274c632016-06-13 16:44:08 -0700692}
693
Irvelffc9efc2016-07-27 15:16:37 -0700694void SurfaceInterceptor::saveDisplayCreation(const DisplayDeviceState& info) {
695 if (!mEnabled) {
696 return;
697 }
698 ATRACE_CALL();
699 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
700 addDisplayCreationLocked(createTraceIncrementLocked(), info);
701}
702
Dominik Laskowski663bd282018-04-19 15:26:54 -0700703void SurfaceInterceptor::saveDisplayDeletion(int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700704 if (!mEnabled) {
705 return;
706 }
707 ATRACE_CALL();
708 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700709 addDisplayDeletionLocked(createTraceIncrementLocked(), sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700710}
711
Dominik Laskowski663bd282018-04-19 15:26:54 -0700712void SurfaceInterceptor::savePowerModeUpdate(int32_t sequenceId, int32_t mode) {
Irvelffc9efc2016-07-27 15:16:37 -0700713 if (!mEnabled) {
714 return;
715 }
716 ATRACE_CALL();
717 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700718 addPowerModeUpdateLocked(createTraceIncrementLocked(), sequenceId, mode);
Irvelffc9efc2016-07-27 15:16:37 -0700719}
720
Lloyd Pique4dccc412018-01-22 17:21:36 -0800721} // namespace impl
Irvelc274c632016-06-13 16:44:08 -0700722} // namespace android
Ady Abrahamb0dbdaa2020-01-06 16:19:42 -0800723
724// TODO(b/129481165): remove the #pragma below and fix conversion issues
725#pragma clang diagnostic pop // ignored "-Wconversion"