blob: f504c13a97d2f0c2042adac982bd2f1a1b074689 [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 */
Irvelc274c632016-06-13 16:44:08 -070016#undef LOG_TAG
17#define LOG_TAG "SurfaceInterceptor"
18#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19
20#include "Layer.h"
21#include "SurfaceFlinger.h"
22#include "SurfaceInterceptor.h"
Colin Cross63549382016-10-26 12:52:53 -070023
Irvelc274c632016-06-13 16:44:08 -070024#include <fstream>
25
Mark Salyzyn4dad9ce2016-09-29 08:08:05 -070026#include <android-base/file.h>
27#include <log/log.h>
28#include <utils/Trace.h>
29
Irvelc274c632016-06-13 16:44:08 -070030namespace android {
31
32// ----------------------------------------------------------------------------
Marissa Wall61c58622018-07-18 10:12:20 -070033// TODO(marissaw): add new layer state values to SurfaceInterceptor
Irvelc274c632016-06-13 16:44:08 -070034
Lloyd Pique4dccc412018-01-22 17:21:36 -080035SurfaceInterceptor::~SurfaceInterceptor() = default;
36
37namespace impl {
38
Robert Carr0d480722017-01-10 16:42:54 -080039SurfaceInterceptor::SurfaceInterceptor(SurfaceFlinger* flinger)
40 : mFlinger(flinger)
41{
42}
43
Irvelffc9efc2016-07-27 15:16:37 -070044void SurfaceInterceptor::enable(const SortedVector<sp<Layer>>& layers,
45 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays)
46{
Irvelc274c632016-06-13 16:44:08 -070047 if (mEnabled) {
48 return;
49 }
Irvelffc9efc2016-07-27 15:16:37 -070050 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -070051 mEnabled = true;
Irvelffc9efc2016-07-27 15:16:37 -070052 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
53 saveExistingDisplaysLocked(displays);
54 saveExistingSurfacesLocked(layers);
Irvelc274c632016-06-13 16:44:08 -070055}
56
57void SurfaceInterceptor::disable() {
Irvelc274c632016-06-13 16:44:08 -070058 if (!mEnabled) {
59 return;
60 }
Irvelffc9efc2016-07-27 15:16:37 -070061 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -070062 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
63 mEnabled = false;
64 status_t err(writeProtoFileLocked());
65 ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied");
66 ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields");
67 mTrace.Clear();
68}
69
Irvelffc9efc2016-07-27 15:16:37 -070070bool SurfaceInterceptor::isEnabled() {
71 return mEnabled;
72}
73
74void SurfaceInterceptor::saveExistingDisplaysLocked(
75 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays)
76{
77 // Caveat: The initial snapshot does not capture the power mode of the existing displays
Irvelc274c632016-06-13 16:44:08 -070078 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -070079 for (size_t i = 0 ; i < displays.size() ; i++) {
80 addDisplayCreationLocked(createTraceIncrementLocked(), displays[i]);
81 addInitialDisplayStateLocked(createTraceIncrementLocked(), displays[i]);
Irvelc274c632016-06-13 16:44:08 -070082 }
83}
84
Irvelffc9efc2016-07-27 15:16:37 -070085void SurfaceInterceptor::saveExistingSurfacesLocked(const SortedVector<sp<Layer>>& layers) {
Irvelc274c632016-06-13 16:44:08 -070086 ATRACE_CALL();
Robert Carr1f0a16a2016-10-24 16:27:39 -070087 for (const auto& l : layers) {
Dan Stoza412903f2017-04-27 13:42:17 -070088 l->traverseInZOrder(LayerVector::StateSet::Drawing, [this](Layer* layer) {
Robert Carr1f0a16a2016-10-24 16:27:39 -070089 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
90 addInitialSurfaceStateLocked(createTraceIncrementLocked(), layer);
91 });
Irvelc274c632016-06-13 16:44:08 -070092 }
Irvelffc9efc2016-07-27 15:16:37 -070093}
94
95void SurfaceInterceptor::addInitialSurfaceStateLocked(Increment* increment,
96 const sp<const Layer>& layer)
97{
Irvelc274c632016-06-13 16:44:08 -070098 Transaction* transaction(increment->mutable_transaction());
99 transaction->set_synchronous(layer->mTransactionFlags & BnSurfaceComposer::eSynchronous);
100 transaction->set_animation(layer->mTransactionFlags & BnSurfaceComposer::eAnimation);
101
102 const int32_t layerId(getLayerId(layer));
Marissa Wallf58c14b2018-07-24 10:50:43 -0700103 addPositionLocked(transaction, layerId, layer->mCurrentState.active_legacy.transform.tx(),
104 layer->mCurrentState.active_legacy.transform.ty());
Irvelc274c632016-06-13 16:44:08 -0700105 addDepthLocked(transaction, layerId, layer->mCurrentState.z);
chaviw13fdc492017-06-27 12:40:18 -0700106 addAlphaLocked(transaction, layerId, layer->mCurrentState.color.a);
Marissa Wallf58c14b2018-07-24 10:50:43 -0700107 addTransparentRegionLocked(transaction, layerId,
108 layer->mCurrentState.activeTransparentRegion_legacy);
Irvelc274c632016-06-13 16:44:08 -0700109 addLayerStackLocked(transaction, layerId, layer->mCurrentState.layerStack);
Marissa Wallf58c14b2018-07-24 10:50:43 -0700110 addCropLocked(transaction, layerId, layer->mCurrentState.crop_legacy);
111 if (layer->mCurrentState.barrierLayer_legacy != nullptr) {
112 addDeferTransactionLocked(transaction, layerId,
113 layer->mCurrentState.barrierLayer_legacy.promote(),
114 layer->mCurrentState.frameNumber_legacy);
Irvelc274c632016-06-13 16:44:08 -0700115 }
Marissa Wallf58c14b2018-07-24 10:50:43 -0700116 addFinalCropLocked(transaction, layerId, layer->mCurrentState.finalCrop_legacy);
Irvelc274c632016-06-13 16:44:08 -0700117 addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode());
118 addFlagsLocked(transaction, layerId, layer->mCurrentState.flags);
119}
120
Irvelffc9efc2016-07-27 15:16:37 -0700121void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment,
122 const DisplayDeviceState& display)
123{
124 Transaction* transaction(increment->mutable_transaction());
125 transaction->set_synchronous(false);
126 transaction->set_animation(false);
127
Dominik Laskowski663bd282018-04-19 15:26:54 -0700128 addDisplaySurfaceLocked(transaction, display.sequenceId, display.surface);
129 addDisplayLayerStackLocked(transaction, display.sequenceId, display.layerStack);
130 addDisplaySizeLocked(transaction, display.sequenceId, display.width, display.height);
131 addDisplayProjectionLocked(transaction, display.sequenceId, display.orientation,
Irvelffc9efc2016-07-27 15:16:37 -0700132 display.viewport, display.frame);
133}
134
Irvelc274c632016-06-13 16:44:08 -0700135status_t SurfaceInterceptor::writeProtoFileLocked() {
136 ATRACE_CALL();
Colin Cross63549382016-10-26 12:52:53 -0700137 std::string output;
138
Irvelc274c632016-06-13 16:44:08 -0700139 if (!mTrace.IsInitialized()) {
140 return NOT_ENOUGH_DATA;
141 }
Colin Cross63549382016-10-26 12:52:53 -0700142 if (!mTrace.SerializeToString(&output)) {
Irvelc274c632016-06-13 16:44:08 -0700143 return PERMISSION_DENIED;
144 }
Colin Cross63549382016-10-26 12:52:53 -0700145 if (!android::base::WriteStringToFile(output, mOutputFileName, true)) {
146 return PERMISSION_DENIED;
147 }
148
Irvelc274c632016-06-13 16:44:08 -0700149 return NO_ERROR;
150}
151
Irvel3017c612016-08-09 16:50:06 -0700152const sp<const Layer> SurfaceInterceptor::getLayer(const wp<const IBinder>& weakHandle) {
153 const sp<const IBinder>& handle(weakHandle.promote());
Irvelc274c632016-06-13 16:44:08 -0700154 const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
155 const sp<const Layer> layer(layerHandle->owner.promote());
156 // layer could be a nullptr at this point
157 return layer;
158}
159
160const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) {
161 return layer->getName().string();
162}
163
164int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) {
165 return layer->sequence;
166}
167
Irvelffc9efc2016-07-27 15:16:37 -0700168Increment* SurfaceInterceptor::createTraceIncrementLocked() {
Irvelc274c632016-06-13 16:44:08 -0700169 Increment* increment(mTrace.add_increment());
170 increment->set_time_stamp(systemTime());
171 return increment;
172}
173
Irvelffc9efc2016-07-27 15:16:37 -0700174SurfaceChange* SurfaceInterceptor::createSurfaceChangeLocked(Transaction* transaction,
175 int32_t layerId)
176{
177 SurfaceChange* change(transaction->add_surface_change());
Irvelc274c632016-06-13 16:44:08 -0700178 change->set_id(layerId);
179 return change;
180}
181
Irvelffc9efc2016-07-27 15:16:37 -0700182DisplayChange* SurfaceInterceptor::createDisplayChangeLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700183 int32_t sequenceId)
Irvelffc9efc2016-07-27 15:16:37 -0700184{
185 DisplayChange* dispChange(transaction->add_display_change());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700186 dispChange->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700187 return dispChange;
188}
189
Irvelc274c632016-06-13 16:44:08 -0700190void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) {
191 protoRect->set_left(rect.left);
192 protoRect->set_top(rect.top);
193 protoRect->set_right(rect.right);
194 protoRect->set_bottom(rect.bottom);
195}
196
Irvelffc9efc2016-07-27 15:16:37 -0700197void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId,
198 float x, float y)
Irvelc274c632016-06-13 16:44:08 -0700199{
Irvelffc9efc2016-07-27 15:16:37 -0700200 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700201 PositionChange* posChange(change->mutable_position());
202 posChange->set_x(x);
203 posChange->set_y(y);
204}
205
Irvelffc9efc2016-07-27 15:16:37 -0700206void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId,
207 uint32_t z)
208{
209 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700210 LayerChange* depthChange(change->mutable_layer());
211 depthChange->set_layer(z);
212}
213
214void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w,
215 uint32_t h)
216{
Irvelffc9efc2016-07-27 15:16:37 -0700217 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700218 SizeChange* sizeChange(change->mutable_size());
219 sizeChange->set_w(w);
220 sizeChange->set_h(h);
221}
222
Irvelffc9efc2016-07-27 15:16:37 -0700223void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId,
224 float alpha)
225{
226 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700227 AlphaChange* alphaChange(change->mutable_alpha());
228 alphaChange->set_alpha(alpha);
229}
230
231void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId,
232 const layer_state_t::matrix22_t& matrix)
233{
Irvelffc9efc2016-07-27 15:16:37 -0700234 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700235 MatrixChange* matrixChange(change->mutable_matrix());
236 matrixChange->set_dsdx(matrix.dsdx);
237 matrixChange->set_dtdx(matrix.dtdx);
238 matrixChange->set_dsdy(matrix.dsdy);
239 matrixChange->set_dtdy(matrix.dtdy);
240}
241
Irvelffc9efc2016-07-27 15:16:37 -0700242void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction,
243 int32_t layerId, const Region& transRegion)
Irvelc274c632016-06-13 16:44:08 -0700244{
Irvelffc9efc2016-07-27 15:16:37 -0700245 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700246 TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint());
247
248 for (const auto& rect : transRegion) {
249 Rectangle* protoRect(transparentChange->add_region());
250 setProtoRectLocked(protoRect, rect);
251 }
252}
253
Irvelffc9efc2016-07-27 15:16:37 -0700254void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId,
255 uint8_t flags)
256{
Irvelc274c632016-06-13 16:44:08 -0700257 // There can be multiple flags changed
258 if (flags & layer_state_t::eLayerHidden) {
Irvelffc9efc2016-07-27 15:16:37 -0700259 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700260 HiddenFlagChange* flagChange(change->mutable_hidden_flag());
261 flagChange->set_hidden_flag(true);
262 }
263 if (flags & layer_state_t::eLayerOpaque) {
Irvelffc9efc2016-07-27 15:16:37 -0700264 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700265 OpaqueFlagChange* flagChange(change->mutable_opaque_flag());
266 flagChange->set_opaque_flag(true);
267 }
268 if (flags & layer_state_t::eLayerSecure) {
Irvelffc9efc2016-07-27 15:16:37 -0700269 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700270 SecureFlagChange* flagChange(change->mutable_secure_flag());
271 flagChange->set_secure_flag(true);
272 }
273}
274
275void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId,
276 uint32_t layerStack)
277{
Irvelffc9efc2016-07-27 15:16:37 -0700278 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700279 LayerStackChange* layerStackChange(change->mutable_layer_stack());
280 layerStackChange->set_layer_stack(layerStack);
281}
282
283void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
284 const Rect& rect)
285{
Irvelffc9efc2016-07-27 15:16:37 -0700286 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700287 CropChange* cropChange(change->mutable_crop());
288 Rectangle* protoRect(cropChange->mutable_rectangle());
289 setProtoRectLocked(protoRect, rect);
290}
291
292void SurfaceInterceptor::addFinalCropLocked(Transaction* transaction, int32_t layerId,
293 const Rect& rect)
294{
Irvelffc9efc2016-07-27 15:16:37 -0700295 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700296 FinalCropChange* finalCropChange(change->mutable_final_crop());
297 Rectangle* protoRect(finalCropChange->mutable_rectangle());
298 setProtoRectLocked(protoRect, rect);
299}
300
301void SurfaceInterceptor::addDeferTransactionLocked(Transaction* transaction, int32_t layerId,
Robert Carr0d480722017-01-10 16:42:54 -0800302 const sp<const Layer>& layer, uint64_t frameNumber)
Irvelc274c632016-06-13 16:44:08 -0700303{
Irvelffc9efc2016-07-27 15:16:37 -0700304 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700305 if (layer == nullptr) {
306 ALOGE("An existing layer could not be retrieved with the handle"
307 " for the deferred transaction");
308 return;
309 }
310 DeferredTransactionChange* deferTransaction(change->mutable_deferred_transaction());
311 deferTransaction->set_layer_id(getLayerId(layer));
312 deferTransaction->set_frame_number(frameNumber);
313}
314
Irvelffc9efc2016-07-27 15:16:37 -0700315void SurfaceInterceptor::addOverrideScalingModeLocked(Transaction* transaction,
316 int32_t layerId, int32_t overrideScalingMode)
Irvelc274c632016-06-13 16:44:08 -0700317{
Irvelffc9efc2016-07-27 15:16:37 -0700318 SurfaceChange* change(createSurfaceChangeLocked(transaction, layerId));
Irvelc274c632016-06-13 16:44:08 -0700319 OverrideScalingModeChange* overrideChange(change->mutable_override_scaling_mode());
320 overrideChange->set_override_scaling_mode(overrideScalingMode);
321}
322
Irvelffc9efc2016-07-27 15:16:37 -0700323void SurfaceInterceptor::addSurfaceChangesLocked(Transaction* transaction,
Irvelc274c632016-06-13 16:44:08 -0700324 const layer_state_t& state)
325{
326 const sp<const Layer> layer(getLayer(state.surface));
327 if (layer == nullptr) {
328 ALOGE("An existing layer could not be retrieved with the surface "
329 "from the layer_state_t surface in the update transaction");
330 return;
331 }
332
333 const int32_t layerId(getLayerId(layer));
334
335 if (state.what & layer_state_t::ePositionChanged) {
336 addPositionLocked(transaction, layerId, state.x, state.y);
337 }
338 if (state.what & layer_state_t::eLayerChanged) {
339 addDepthLocked(transaction, layerId, state.z);
340 }
341 if (state.what & layer_state_t::eSizeChanged) {
342 addSizeLocked(transaction, layerId, state.w, state.h);
343 }
344 if (state.what & layer_state_t::eAlphaChanged) {
345 addAlphaLocked(transaction, layerId, state.alpha);
346 }
347 if (state.what & layer_state_t::eMatrixChanged) {
348 addMatrixLocked(transaction, layerId, state.matrix);
349 }
350 if (state.what & layer_state_t::eTransparentRegionChanged) {
351 addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
352 }
353 if (state.what & layer_state_t::eFlagsChanged) {
354 addFlagsLocked(transaction, layerId, state.flags);
355 }
356 if (state.what & layer_state_t::eLayerStackChanged) {
357 addLayerStackLocked(transaction, layerId, state.layerStack);
358 }
Marissa Wallf58c14b2018-07-24 10:50:43 -0700359 if (state.what & layer_state_t::eCropChanged_legacy) {
360 addCropLocked(transaction, layerId, state.crop_legacy);
Irvelc274c632016-06-13 16:44:08 -0700361 }
Marissa Wallf58c14b2018-07-24 10:50:43 -0700362 if (state.what & layer_state_t::eDeferTransaction_legacy) {
Robert Carr0d480722017-01-10 16:42:54 -0800363 sp<Layer> otherLayer = nullptr;
Marissa Wallf58c14b2018-07-24 10:50:43 -0700364 if (state.barrierHandle_legacy != nullptr) {
365 otherLayer =
366 static_cast<Layer::Handle*>(state.barrierHandle_legacy.get())->owner.promote();
367 } else if (state.barrierGbp_legacy != nullptr) {
368 auto const& gbp = state.barrierGbp_legacy;
Robert Carr0d480722017-01-10 16:42:54 -0800369 if (mFlinger->authenticateSurfaceTextureLocked(gbp)) {
370 otherLayer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
371 } else {
372 ALOGE("Attempt to defer transaction to to an unrecognized GraphicBufferProducer");
373 }
374 }
Marissa Wallf58c14b2018-07-24 10:50:43 -0700375 addDeferTransactionLocked(transaction, layerId, otherLayer, state.frameNumber_legacy);
Irvelc274c632016-06-13 16:44:08 -0700376 }
Marissa Wallf58c14b2018-07-24 10:50:43 -0700377 if (state.what & layer_state_t::eFinalCropChanged_legacy) {
378 addFinalCropLocked(transaction, layerId, state.finalCrop_legacy);
Irvelc274c632016-06-13 16:44:08 -0700379 }
380 if (state.what & layer_state_t::eOverrideScalingModeChanged) {
381 addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode);
382 }
383}
384
Irvelffc9efc2016-07-27 15:16:37 -0700385void SurfaceInterceptor::addDisplayChangesLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700386 const DisplayState& state, int32_t sequenceId)
Irvelc274c632016-06-13 16:44:08 -0700387{
Irvelffc9efc2016-07-27 15:16:37 -0700388 if (state.what & DisplayState::eSurfaceChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700389 addDisplaySurfaceLocked(transaction, sequenceId, state.surface);
Irvelffc9efc2016-07-27 15:16:37 -0700390 }
391 if (state.what & DisplayState::eLayerStackChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700392 addDisplayLayerStackLocked(transaction, sequenceId, state.layerStack);
Irvelffc9efc2016-07-27 15:16:37 -0700393 }
394 if (state.what & DisplayState::eDisplaySizeChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700395 addDisplaySizeLocked(transaction, sequenceId, state.width, state.height);
Irvelffc9efc2016-07-27 15:16:37 -0700396 }
397 if (state.what & DisplayState::eDisplayProjectionChanged) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700398 addDisplayProjectionLocked(transaction, sequenceId, state.orientation, state.viewport,
Irvelffc9efc2016-07-27 15:16:37 -0700399 state.frame);
Irvelc274c632016-06-13 16:44:08 -0700400 }
401}
402
Irvelffc9efc2016-07-27 15:16:37 -0700403void SurfaceInterceptor::addTransactionLocked(Increment* increment,
404 const Vector<ComposerState>& stateUpdates,
405 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays,
406 const Vector<DisplayState>& changedDisplays, uint32_t transactionFlags)
407{
408 Transaction* transaction(increment->mutable_transaction());
409 transaction->set_synchronous(transactionFlags & BnSurfaceComposer::eSynchronous);
410 transaction->set_animation(transactionFlags & BnSurfaceComposer::eAnimation);
411 for (const auto& compState: stateUpdates) {
412 addSurfaceChangesLocked(transaction, compState.state);
413 }
414 for (const auto& disp: changedDisplays) {
415 ssize_t dpyIdx = displays.indexOfKey(disp.token);
416 if (dpyIdx >= 0) {
417 const DisplayDeviceState& dispState(displays.valueAt(dpyIdx));
Dominik Laskowski663bd282018-04-19 15:26:54 -0700418 addDisplayChangesLocked(transaction, disp, dispState.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700419 }
420 }
Irvelc274c632016-06-13 16:44:08 -0700421}
422
Irvelffc9efc2016-07-27 15:16:37 -0700423void SurfaceInterceptor::addSurfaceCreationLocked(Increment* increment,
424 const sp<const Layer>& layer)
425{
426 SurfaceCreation* creation(increment->mutable_surface_creation());
427 creation->set_id(getLayerId(layer));
428 creation->set_name(getLayerName(layer));
Marissa Wallf58c14b2018-07-24 10:50:43 -0700429 creation->set_w(layer->mCurrentState.active_legacy.w);
430 creation->set_h(layer->mCurrentState.active_legacy.h);
Irvelc274c632016-06-13 16:44:08 -0700431}
432
Irvelffc9efc2016-07-27 15:16:37 -0700433void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
434 const sp<const Layer>& layer)
435{
436 SurfaceDeletion* deletion(increment->mutable_surface_deletion());
437 deletion->set_id(getLayerId(layer));
438}
439
440void SurfaceInterceptor::addBufferUpdateLocked(Increment* increment, const sp<const Layer>& layer,
Irvelc274c632016-06-13 16:44:08 -0700441 uint32_t width, uint32_t height, uint64_t frameNumber)
442{
443 BufferUpdate* update(increment->mutable_buffer_update());
444 update->set_id(getLayerId(layer));
445 update->set_w(width);
446 update->set_h(height);
447 update->set_frame_number(frameNumber);
448}
449
Irvelffc9efc2016-07-27 15:16:37 -0700450void SurfaceInterceptor::addVSyncUpdateLocked(Increment* increment, nsecs_t timestamp) {
Irvelc274c632016-06-13 16:44:08 -0700451 VSyncEvent* event(increment->mutable_vsync_event());
452 event->set_when(timestamp);
453}
454
Dominik Laskowski663bd282018-04-19 15:26:54 -0700455void SurfaceInterceptor::addDisplaySurfaceLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700456 const sp<const IGraphicBufferProducer>& surface)
Irvelc274c632016-06-13 16:44:08 -0700457{
Irvelffc9efc2016-07-27 15:16:37 -0700458 if (surface == nullptr) {
Irvelc274c632016-06-13 16:44:08 -0700459 return;
460 }
Irvelffc9efc2016-07-27 15:16:37 -0700461 uint64_t bufferQueueId = 0;
462 status_t err(surface->getUniqueId(&bufferQueueId));
463 if (err == NO_ERROR) {
Dominik Laskowski663bd282018-04-19 15:26:54 -0700464 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700465 DispSurfaceChange* surfaceChange(dispChange->mutable_surface());
466 surfaceChange->set_buffer_queue_id(bufferQueueId);
467 surfaceChange->set_buffer_queue_name(surface->getConsumerName().string());
468 }
469 else {
470 ALOGE("invalid graphic buffer producer received while tracing a display change (%s)",
471 strerror(-err));
472 }
Irvelc274c632016-06-13 16:44:08 -0700473}
474
Irvelffc9efc2016-07-27 15:16:37 -0700475void SurfaceInterceptor::addDisplayLayerStackLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700476 int32_t sequenceId, uint32_t layerStack)
Irvelffc9efc2016-07-27 15:16:37 -0700477{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700478 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700479 LayerStackChange* layerStackChange(dispChange->mutable_layer_stack());
480 layerStackChange->set_layer_stack(layerStack);
481}
482
Dominik Laskowski663bd282018-04-19 15:26:54 -0700483void SurfaceInterceptor::addDisplaySizeLocked(Transaction* transaction, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700484 uint32_t w, uint32_t h)
485{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700486 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700487 SizeChange* sizeChange(dispChange->mutable_size());
488 sizeChange->set_w(w);
489 sizeChange->set_h(h);
490}
491
492void SurfaceInterceptor::addDisplayProjectionLocked(Transaction* transaction,
Dominik Laskowski663bd282018-04-19 15:26:54 -0700493 int32_t sequenceId, int32_t orientation, const Rect& viewport, const Rect& frame)
Irvelffc9efc2016-07-27 15:16:37 -0700494{
Dominik Laskowski663bd282018-04-19 15:26:54 -0700495 DisplayChange* dispChange(createDisplayChangeLocked(transaction, sequenceId));
Irvelffc9efc2016-07-27 15:16:37 -0700496 ProjectionChange* projectionChange(dispChange->mutable_projection());
497 projectionChange->set_orientation(orientation);
498 Rectangle* viewportRect(projectionChange->mutable_viewport());
499 setProtoRectLocked(viewportRect, viewport);
500 Rectangle* frameRect(projectionChange->mutable_frame());
501 setProtoRectLocked(frameRect, frame);
502}
503
504void SurfaceInterceptor::addDisplayCreationLocked(Increment* increment,
505 const DisplayDeviceState& info)
506{
507 DisplayCreation* creation(increment->mutable_display_creation());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700508 creation->set_id(info.sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700509 creation->set_name(info.displayName);
510 creation->set_type(info.type);
511 creation->set_is_secure(info.isSecure);
512}
513
Dominik Laskowski663bd282018-04-19 15:26:54 -0700514void SurfaceInterceptor::addDisplayDeletionLocked(Increment* increment, int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700515 DisplayDeletion* deletion(increment->mutable_display_deletion());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700516 deletion->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700517}
518
Dominik Laskowski663bd282018-04-19 15:26:54 -0700519void SurfaceInterceptor::addPowerModeUpdateLocked(Increment* increment, int32_t sequenceId,
Irvelffc9efc2016-07-27 15:16:37 -0700520 int32_t mode)
521{
522 PowerModeUpdate* powerModeUpdate(increment->mutable_power_mode_update());
Dominik Laskowski663bd282018-04-19 15:26:54 -0700523 powerModeUpdate->set_id(sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700524 powerModeUpdate->set_mode(mode);
525}
526
527void SurfaceInterceptor::saveTransaction(const Vector<ComposerState>& stateUpdates,
528 const DefaultKeyedVector< wp<IBinder>, DisplayDeviceState>& displays,
529 const Vector<DisplayState>& changedDisplays, uint32_t flags)
530{
531 if (!mEnabled || (stateUpdates.size() <= 0 && changedDisplays.size() <= 0)) {
532 return;
533 }
Irvelc274c632016-06-13 16:44:08 -0700534 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700535 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
536 addTransactionLocked(createTraceIncrementLocked(), stateUpdates, displays, changedDisplays,
537 flags);
538}
539
540void SurfaceInterceptor::saveSurfaceCreation(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700541 if (!mEnabled || layer == nullptr) {
542 return;
543 }
Irvelc274c632016-06-13 16:44:08 -0700544 ATRACE_CALL();
Irvelffc9efc2016-07-27 15:16:37 -0700545 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
546 addSurfaceCreationLocked(createTraceIncrementLocked(), layer);
547}
548
549void SurfaceInterceptor::saveSurfaceDeletion(const sp<const Layer>& layer) {
Irvelc274c632016-06-13 16:44:08 -0700550 if (!mEnabled || layer == nullptr) {
551 return;
552 }
Irvelffc9efc2016-07-27 15:16:37 -0700553 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700554 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700555 addSurfaceDeletionLocked(createTraceIncrementLocked(), layer);
Irvelc274c632016-06-13 16:44:08 -0700556}
557
558void SurfaceInterceptor::saveBufferUpdate(const sp<const Layer>& layer, uint32_t width,
559 uint32_t height, uint64_t frameNumber)
560{
Irvelc274c632016-06-13 16:44:08 -0700561 if (!mEnabled || layer == nullptr) {
562 return;
563 }
Irvelffc9efc2016-07-27 15:16:37 -0700564 ATRACE_CALL();
Irvelc274c632016-06-13 16:44:08 -0700565 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700566 addBufferUpdateLocked(createTraceIncrementLocked(), layer, width, height, frameNumber);
Irvelc274c632016-06-13 16:44:08 -0700567}
568
569void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
570 if (!mEnabled) {
571 return;
572 }
573 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Irvelffc9efc2016-07-27 15:16:37 -0700574 addVSyncUpdateLocked(createTraceIncrementLocked(), timestamp);
Irvelc274c632016-06-13 16:44:08 -0700575}
576
Irvelffc9efc2016-07-27 15:16:37 -0700577void SurfaceInterceptor::saveDisplayCreation(const DisplayDeviceState& info) {
578 if (!mEnabled) {
579 return;
580 }
581 ATRACE_CALL();
582 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
583 addDisplayCreationLocked(createTraceIncrementLocked(), info);
584}
585
Dominik Laskowski663bd282018-04-19 15:26:54 -0700586void SurfaceInterceptor::saveDisplayDeletion(int32_t sequenceId) {
Irvelffc9efc2016-07-27 15:16:37 -0700587 if (!mEnabled) {
588 return;
589 }
590 ATRACE_CALL();
591 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700592 addDisplayDeletionLocked(createTraceIncrementLocked(), sequenceId);
Irvelffc9efc2016-07-27 15:16:37 -0700593}
594
Dominik Laskowski663bd282018-04-19 15:26:54 -0700595void SurfaceInterceptor::savePowerModeUpdate(int32_t sequenceId, int32_t mode) {
Irvelffc9efc2016-07-27 15:16:37 -0700596 if (!mEnabled) {
597 return;
598 }
599 ATRACE_CALL();
600 std::lock_guard<std::mutex> protoGuard(mTraceMutex);
Dominik Laskowski663bd282018-04-19 15:26:54 -0700601 addPowerModeUpdateLocked(createTraceIncrementLocked(), sequenceId, mode);
Irvelffc9efc2016-07-27 15:16:37 -0700602}
603
Lloyd Pique4dccc412018-01-22 17:21:36 -0800604} // namespace impl
Irvelc274c632016-06-13 16:44:08 -0700605} // namespace android